AI FX Bot Lab: Real Trading Experiments

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

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

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

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

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

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

The five bots closed 13 trades on August 4 and won 10 of them. That sounds like a strong session, but the realized result was negative 16 yen after swap.The problem was not a lack of winning trades. It was the size and shape of the losses. The average winner was 62.6 yen, while the average loser was 208 yen, leaving the combined payoff ratio at only 0.30.BoundSniper Bot won four of five closed trades, yet one 263-yen loss and 18 yen of negative swap erased all four small wins. ML_ScoreAnalyst produced a 303-yen winner and a 304-yen loser, almost a perfect cancellation. I had to look at those two numbers twice.The MT5 reports also showed two positions still open at the end of the day. ML_ScoreAnalyst carried a 90-yen floating loss, and MAribbonTrader carried a 111-yen floating loss. The realized result was close to flat, but the risk had not disappeared.Bot-by-Bot Results■ GateGrid AI +99 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +99 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yenOpen P/L: 0 yen■ BoundSniper Bot -225 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +56 yenGross loss: -263 yenSwap: -18 yenPayoff ratio: 0.05Max loss: -263 yenOpen P/L: 0 yen■ LLMBridgeTrader +61 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +118 yenGross loss: -57 yenPayoff ratio: 1.04Max loss: -57 yenOpen P/L: 0 yen■ ML_ScoreAnalyst -1 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +303 yenGross loss: -304 yenPayoff ratio: 1.00Max loss: -304 yenOpen P/L: -90 yen■ MAribbonTrader +50 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +50 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yenOpen P/L: -111 yen■ Total -16 yenRecord: 10W / 3LWin rate: 76.9%Gross profit: +626 yenGross loss: -624 yenSwap: -18 yenPayoff ratio: 0.30Max loss: -304 yenOpen P/L: -201 yenThe gross trading result before swap was positive by only 2 yen. Once the 18-yen swap was included, the realized result became negative 16 yen.Today’s Theme: A High Win Rate Can Hide Weak ExitsThe day was a clean example of why I do not want to rank these bots by win rate alone. Ten winners looked reassuring, but most of them were too small to absorb the three losing trades.This matters even more for bots that let an LLM decide whether to HOLD, CLOSE, or REVERSE. An entry can be reasonable and still become a poor trade if the model keeps defending the position for too long. The useful question is not only whether the model predicted the direction correctly, but whether it stopped believing its own thesis at the right moment.The MT5 report tells me when and where a trade was closed. It does not contain the full AI response, confidence score, chart interpretation, or exit reason. To evaluate the LLM layer properly, each deal now needs to be joined with the model log that produced OPEN, HOLD, CLOSE, REVERSE, WAIT, or EXIT.GateGrid AI: Clean Realized Result, but the Exit Reason Is MissingGateGrid AI finished with two winners worth 99 yen in total and no open position. Six earlier pending orders were canceled before two buy-stop orders were eventually filled, so the order-management layer did not simply leave old entries sitting in the market.The first position was opened at 14:44 and the second at 17:08. Both were closed by market orders around 17:12, producing 91 yen and 8 yen. Closing the two grid legs together left the account flat, which is the result I want to see from a strategy that manages positions as a group.Still, the report does not show whether the close came from trailing logic, a local Ollama decision, a grid-level target, or another rule. A profitable exit is welcome, but one two-trade sample does not tell me whether the exit manager is improving. The next step is to match the close timestamp with the CatBoost score, ATR state, session gate, Ollama response, and recorded exit trigger.BoundSniper Bot: Four Wins Could Not Repair One Old LossBoundSniper Bot posted four winners after its first closing trade, but those wins were only 31, 8, 10, and 7 yen. Together they earned 56 yen. The earlier loss was 263 yen, with another 18 yen charged as swap.That single exit made the whole day negative 225 yen. Seeing a payoff ratio of 0.05 made me pause; the bot could repeat this exact 80% win rate and still lose money.BoundSniper itself does not predict the market. It receives TradingView signals through the webhook pipeline and executes them in MT5. The issue therefore appears less like an MT5 execution problem and more like an exit problem in the upstream TradingView strategy, or in the management of a position carried from the previous session.The losing position was closed at 01:02, while no corresponding same-day entry appears in the report. That suggests it was already open before August 4. I cannot determine from this report whether the exit was late, but the negative swap and oversized loss make the inherited-position logic worth reviewing.LLMBridgeTrader: The Most Balanced Exit Profile of the DayLLMBridgeTrader closed three EURUSD trades for a net gain of 61 yen. Its two winners totaled 118 yen, while its single loss was 57 yen, producing a payoff ratio of 1.04.The first short was closed by a stop order for a 93-yen profit. After that, two long positions were opened and closed within about 15 minutes, one for a 57-yen loss and one for a 25-yen gain. The loss was contained rather than allowed to grow into the largest loss of the session.This was the best balance between winning and losing size among the bots that recorded both outcomes. The numbers do not prove that the LLM made good discretionary decisions, though. The MT5 report does not reveal whether those exits were CLOSE responses, fixed safety rules, stop movement, or scheduled reevaluations.Because LLMBridgeTrader can choose OPEN, HOLD, CLOSE, and REVERSE, its real experiment is the change of mind. The valuable log is the moment when confidence weakens enough to replace HOLD with CLOSE. Today’s trade sizes look reasonable, but I still need the decision trace before giving the model credit.ML_ScoreAnalyst: One Winner, One Loser, and No Edge Left OverML_ScoreAnalyst earned 303 yen on its first GBPJPY trade and lost 304 yen on the next. The realized result was negative 1 yen, almost a numerical draw, while a third long position remained open with a 90-yen floating loss.The 304-yen stop was the largest closed loss across the five bots. It canceled a trade that had been held for several hours and reached a similarly sized profit. Again, almost the same amount in both directions — not disastrous, but not much of an edge either.This bot uses CatBoost to score entries rather than an LLM to interpret chart context. Its entry model may still have selected valid breakout candidates, but the day shows that entry scoring alone cannot create positive expectancy when the exit distribution is symmetrical.The open third trade also means the day cannot be evaluated only from the negative 1-yen realized result. The next useful comparison is the entry score of the 303-yen winner, the 304-yen loser, and the still-open trade. If the scores were similar, the model may not be separating strong and weak setups yet.MAribbonTrader: A Good Protective Exit Followed by a Difficult Re-entryMAribbonTrader closed one GBPCAD long for a 50-yen gain. The position was exited through a stop above the entry price, which looks like a protective stop that had already locked in profit.About ten minutes later, the bot opened another long. That second position ended the reporting period with a 111-yen floating loss. The realized exit was good, but the immediate return to the same direction is the part I want to inspect.MAribbonTrader sends chart images, moving-average ribbons, higher-timeframe context, support and resistance information, ranges, and channel structure to Qwen. The model is supposed to distinguish a fresh setup from a chart that only resembles the previous one.The open question in the log is whether the second BUY came from genuinely renewed evidence or from a bullish interpretation that never really changed. The first trade shows that EXIT can protect profit. The second entry will test whether WAIT is strong enough after that exit.ClosingThe five bots did not have a bad day in the usual sense. Three finished with positive realized results, one was almost flat, and only BoundSniper Bot recorded a clear realized loss.Yet the fleet still finished negative because the losing trades were allowed to carry much more weight than most of the winners. A 76.9% win rate did not rescue a 0.30 payoff ratio.For the next review, I care less about adding another entry filter. I want the decision logs around the three losing exits, the BoundSniper position carried into the day, and MAribbonTrader’s quick re-entry. The bots are finding winners. I am not convinced they all know when their idea has expired.② Substack NoteFive MT5 bots closed 13 trades on August 4.The record was 10 wins and 3 losses, but the realized result was still -16 yen. BoundSniper won four times, yet one larger loss erased them. ML_ScoreAnalyst made +303 yen and then lost 304 yen.The fleet’s win rate was 76.9%. Its payoff ratio was only 0.30.The entries were not the main problem today. The exits were. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

Hello! I have been running a parallel test of five distinct MT5 automated trading bots to evaluate their real-world behaviors. For the two days of July 30 and 31, the bots successfully covered each other’s weaknesses, resulting in two consecutive days of positive returns. However, looking closely at the data reveals a stark contrast between successful exits and remaining challenges.July 30 Overall Performance: GateGrid AI Dominates with Tiny LossesOn July 30, the portfolio finished with a total profit of 592 yen. The star of the day was GateGrid AI. Alongside a high win rate of 12 wins and 2 losses, the combined losses of the two losing trades were kept to a mere 9 yen, with a maximum loss of 7 yen. With an average win of 68.5 yen and an average loss of 4.5 yen, it achieved an incredible payoff ratio of 15.22, earning 813 yen on its own. Meanwhile, ML_ScoreAnalyst closed a carried position from the previous day for a 215 yen loss, but GateGrid AI’s profits completely covered it. This day proved the strength of admitting defeat quickly and cutting losses.July 31 Overall Performance: Saved by Two Take-Profits Amidst Recurring Exit IssuesOn July 31, the portfolio managed a narrow positive finish of 189 yen. However, the leading bots completely swapped. ML_ScoreAnalyst successfully executed two clean take-profits to earn 593 yen, and BoundSniper Bot added 405 yen through a run of short entries. Their profits were absolutely necessary because yesterday’s hero, GateGrid AI, recorded a massive loss of 843 yen. During a multiple-position unwinding process, GateGrid AI allowed a large loss, dragging down the overall performance. Without ML_ScoreAnalyst, the day would have ended at minus 404 yen.Bot-by-Bot Analysis1. GateGrid AIWhile it can keep losses extremely small as seen on July 30, it still has a weakness of realizing large losses, such as a 451 yen loss on July 31, when unwinding multiple positions. Since its entry accuracy is not bad, the decision-making process for transitioning from holding to closing is the primary challenge.2. BoundSniper BotIt had no submitted trades on July 30, but made a 405 yen profit with a 68.8 percent win rate on July 31. However, it also took a 399 yen loss in just 43 seconds. The structure of stacking small wins only to be heavily reduced by a single loss still exists, suggesting the need for an independent emergency loss limit rule as an execution relay.3. ML_ScoreAnalystIt saved the entire portfolio on July 31 with two clean take-profits totaling 593 yen. Because its targets are clearly defined, its results are very easy to audit. However, as seen with the 215 yen loss on July 30 from a carried position, it is still necessary to accumulate more data on its losing patterns.4. LLMBridgeTraderIt had no submitted trades on July 30. On July 31, it recorded 1 win and 1 loss for a 34 yen profit. It demonstrated a smart move by shifting the stop loss above the entry price to protect the gains of a profitable position.5. MAribbonTraderIt had no realized profits on either day, only recording a minor 6 yen loss in about 14 minutes on July 30. Although it is a highly discretionary bot, it deserves credit for keeping the loss small and exiting early.Summary: Diversification Effects and Remaining Exit ChallengesOver these two days, the portfolio’s diversification effect worked beautifully, with bots covering for each other’s poor performances to secure consecutive winning days. However, the overall payoff ratio on July 31 remained at 0.65, meaning the fundamental risk of average losses exceeding average wins is still unresolved. The success of automated trading depends not on the entries, but on exit discipline—how cheaply the system can admit defeat. I will continue to verify the systems by focusing on the exit data. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

Hello! I have been running a parallel test of five distinct MT5 automated trading bots to evaluate their real-world behaviors and AI decision-making processes. July 28 and 29 provided incredibly insightful data for the portfolio. On July 29, I deliberately left all five bots running through the highly volatile FOMC event instead of shutting them down. The data from these two days delivered a harsh reality check: Event risks like the FOMC do not blow up accounts; ordinary, poorly designed exits and payoff asymmetry are what truly destroy a portfolio.Overall Performance: A 64 percent Win Rate Cannot Outrun Bad ExitsLooking purely at the win rates, the portfolio seemed highly capable of predicting market direction. However, both days resulted in net realized losses.July 28: Total minus 64 JPY (Win Rate 63.6 percent)The fleet closed 7 winning trades and 4 losing trades, ending the day with a realized loss of 64 JPY. The root cause was glaringly obvious: the average winner brought in about 80.4 JPY, while the average loser wiped out 156.8 JPY. The AI successfully called the direction, but it paid far too much when those ideas were wrong.July 29 (FOMC): Total minus 333 JPY (Win Rate 64.3 percent)Despite the FOMC volatility, the damage remained contained with no single closed trade losing more than 314 JPY. The portfolio achieved 18 wins and 10 losses, yet the payoff ratio was a dismal 0.45. The average winner was about 78 JPY, while the average loser reached roughly 174 JPY. FOMC did not create an uncontrolled failure; it was the ordinary exit asymmetry that did most of the damage.Bot-by-Bot Breakdown: Different Brains, Same Exit StrugglesBecause each bot processes information and makes decisions differently, their results and failure points varied drastically.1. BoundSniper Bot: The Disciplined Execution LayerThis bot relays TradingView signals into MT5 and does not predict the market itself. It had no trades on July 28. On July 29, it was the undisputed MVP of the FOMC session, closing 7 wins and 1 loss for a profit of 284 JPY. It posted an incredible payoff ratio of 3.52, proving that fast, externally defined exits can keep risk incredibly small, even during severe market events.2. LLMBridgeTrader: The AI Planner’s HesitationThis AI operates with high autonomy, deciding whether to OPEN, HOLD, CLOSE, or REVERSE a position. On July 28, it closed flat at 0 JPY realized, though it carried an unrealized loss. On July 29, it secured a 105 JPY profit. It successfully protected several winners through stop-based exits, but it also hesitated on holding positions, resulting in late exits and large losses like a 295 JPY loss on July 28 and a 199 JPY loss on July 29.3. GateGrid AI: Small Wins Swallowed by Heavy ExitsThis hybrid bot uses a CatBoost probability gate and an Ollama review to filter entries. It fell victim to the classic “small win, massive loss” trap. On July 28, it lost 65 JPY, as four wins were wiped out by a single 252 JPY loss. On July 29, it lost 259 JPY with a terrible 0.42 payoff ratio. It proved that entry filtering alone cannot repair a fundamentally flawed exit profile.4. ML_ScoreAnalyst: Improving Risk-to-Reward BalanceThis fast bot evaluates confirmed GBPJPY breakouts using a CatBoost score. It had no trades on July 28. On July 29, it lost 69 JPY. Among the losing bots, it came the closest to a balanced risk-to-reward profile with a payoff ratio of 0.88, though its stops were still slightly heavier than its target profits.5. MAribbonTrader: Rich Context, Weakest PayoffsA chart-reading AI that sends MT5 screenshots and rich visual context to a local LLM for discretionary analysis. It won 1 JPY on July 28. On July 29, it lost 394 JPY. Despite receiving the richest visual context of all five bots, it exposed the weakest payoff structure at 0.12. A 60 percent win rate was useless when the average winner of 30 JPY was forced to absorb an average loss of 242 JPY. It highlighted that giving an AI more information does not automatically produce a better exit.Conclusion: The Flaw is Inside the System, Not the EventThe ultimate takeaway from these two days is that the systems were not defeated by a lack of winning trades or by market events. They were defeated by the massive distance between their normal profits and normal losses. The most critical part of an experimental trading model is the brief window of time between the setup weakening and the actual closure of the position. Moving forward, the primary focus must shift away from entry accuracy and prioritize strict exit discipline, ensuring the AI learns how to quickly and cheaply abandon bad ideas. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

ConclusionThe five-bot portfolio finished the session with a realized gain of ¥624. Three bots were positive, one did not trade, and LLMBridgeTrader closed four positions without a single win.The -¥195 stop on its first trade made me pause. The later losses shrank to -¥80, -¥16, and -¥5, so the bot did become quicker about getting out, but it never found a profitable exit during the reporting window. That makes this less of an entry contest and more of a test of when each system gives up on its original idea.MAribbonTrader also needs a closer look despite ending positive. Its +¥316 closing trade appears to have come from a position carried into the day, and the three positions opened and closed on July 27 produced a combined -¥89 before swap. The account made money, but the fresh setups did not.Win rate below includes the zero-yen GateGrid AI closure in the total number of closed trades. Gross profit, gross loss, and payoff ratio exclude swap.Bot-by-bot results■ GateGrid AI +384 yen　Market: EURUSD-　Record: 5W / 0L / 1 flat　Win rate: 83.3%　Gross profit: +384 yen　Gross loss: 0 yen　Payoff ratio: N/A, no losing trade　Max loss: 0 yen■ BoundSniper Bot 0 yen　Trades: None reported　Record: N/A　Win rate: N/A　Gross profit: 0 yen　Gross loss: 0 yen　Payoff ratio: N/A　Max loss: N/A■ LLMBridgeTrader -296 yen　Market: EURUSD-　Record: 0W / 4L　Win rate: 0.0%　Gross profit: 0 yen　Gross loss: -296 yen　Payoff ratio: N/A, no winning trade　Max loss: -195 yen　Unrealized P/L at cutoff: -16 yen■ ML_ScoreAnalyst +300 yen　Market: GBPJPY-　Record: 1W / 0L　Win rate: 100.0%　Gross profit: +300 yen　Gross loss: 0 yen　Payoff ratio: N/A, no losing trade　Max loss: 0 yen■ MAribbonTrader +236 yen　Market: GBPCAD-　Record: 2W / 2L　Win rate: 50.0%　Gross profit: +505 yen　Gross loss: -278 yen　Payoff ratio: 1.82　Max loss: -154 yen　Swap: +9 yen■ Total +624 yen　Record: 8W / 6L / 1 flat　Win rate: 53.3%　Gross profit: +1,189 yen　Gross loss: -574 yen　Payoff ratio: 1.55　Max loss: -195 yen　Swap: +9 yen　Unrealized P/L at cutoff: -16 yenToday’s theme: the MT5 report knows what happened, but not whyThe execution report gives a clear sequence of entries, exits, stops, and take-profits. What it does not contain is the model context behind those actions: confidence, setup type, HOLD or CLOSE reasoning, chart state, or the inputs shown to the LLM.That gap matters most for LLMBridgeTrader. Its design allows the model to choose OPEN, HOLD, CLOSE, and REVERSE while also proposing SL and TP distances. Looking only at the MT5 result, I cannot tell whether the -¥80 market exit was a sensible early escape from a broken setup or a late reaction after the model ignored an earlier warning.The same issue exists in MAribbonTrader. The trading report shows the outcome, but not whether Qwen saw a first pullback to the long-term ribbon, a resistance retest, a narrowing channel, or a reason to switch from HOLD to EXIT. Without that join, a winning trade can look smarter than it was, and a losing trade can look worse than the decision that produced it.GateGrid AIGateGrid AI had the cleanest realized record of the day. It closed six short positions for five gains and one flat result, with no losing exit and no open exposure at the cutoff.The closures came in groups. Two positions were closed around 14:30 for +¥92 and ¥0, while another pair was closed around 16:58 for +¥110 and +¥21. That looks like basket-level management rather than demanding that every grid layer reach an individual target, and it worked well in this session.There is one configuration detail worth checking. The bot overview describes GateGrid AI as a GBPUSD system, but this live report records EURUSD- orders. The analysis here follows the actual account report, though the symbol difference should be confirmed before comparing the result with model thresholds or training data.A payoff ratio cannot be calculated because there was no losing trade. That is a pleasant problem for one day, but six closures are not enough to judge the grid’s real downside. Its max-loss behavior remains untested in this sample.BoundSniper BotNo BoundSniper transaction details were included, so it is recorded as no trade. For a bridge bot, inactivity is not automatically a problem; it may simply mean TradingView sent no qualifying signal.Still, its logs should distinguish between “no alert received,” “alert rejected,” and “order submission failed.” All three create an empty MT5 report, but they describe very different system states.LLMBridgeTraderLLMBridgeTrader was the weak point of the portfolio. Four completed EURUSD- trades lost -¥195, -¥80, -¥16, and -¥5, producing a 0% win rate and the day’s largest single loss.The sequence is not entirely negative from a risk perspective. After the first stop, each completed loss became smaller, which may indicate that later CLOSE decisions reacted faster. I would not claim that from execution data alone, though; the market may simply have moved less.The first buy was closed by a stop at -¥195. Two later buys were closed at market for -¥80 and -¥16, followed by a sell closed at -¥5. A new short was then opened at 23:00 and remained open with -¥16 of unrealized loss at the report cutoff.For a bot with broad LLM discretion, the next useful comparison is not just BUY versus SELL accuracy. Each losing trade should be joined to the model’s confidence, setup label, original SL and TP proposal, every HOLD decision, and the final reason for CLOSE. The exit model is where the evidence is missing.ML_ScoreAnalystML_ScoreAnalyst took one GBPJPY- short and reached its take-profit for +¥300. It was a simple result: one scored entry, one predefined target, and no further exposure.The fixed exit beat the adaptive LLM exits today, but the sample size is one. I would not promote the score threshold or TP setting on this result alone. What it does provide is a useful control case for the more flexible bots: a narrow decision system can be easier to evaluate because the path from signal to result is short.MAribbonTraderMAribbonTrader recorded two wins and two losses, with a payoff ratio of 1.82. That is the strongest measurable payoff ratio among the five bots, since the other profitable systems had no losing trades from which to calculate one.The +¥316 close appears without a corresponding same-day entry and also earned +¥9 in swap, so it was probably a position carried into July 27. After that, the bot closed a fresh long for +¥189, then lost -¥154 and -¥124 on two more longs. Those three same-day round trips netted -¥89.This split matters. The account-level result was +¥236, but the new setups had a difficult day. The -¥154 stop caught my eye because it arrived shortly after the profitable TP, followed almost immediately by another entry and another stop. That may be a re-entry filter problem, a ribbon-state problem, or just a bad patch of GBPCAD movement. The MT5 report cannot settle it.The MAribbon logs should make it possible to check whether the two losing entries shared the same chart context. I would look first at long-term ribbon direction, distance to resistance, whether the move was still an impulse or already a correction, and why the second long was allowed only about ninety seconds after the previous stop.SummaryThe portfolio’s realized result was positive, but the most useful output from the day is not the ¥624. It is the contrast between systems whose exits were explicit and systems whose exits depended on changing model judgment.The next improvement may not be a new prompt or another indicator. A shared trade ID connecting every LLM response, chart snapshot, position action, and MT5 execution would make the losses far more valuable. Right now the numbers are clear, while the decisions that created them are still partly hidden. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

The conclusionJuly 24 was not mainly an entry problem. It was an exit problem.The five-bot portfolio ended the day at -¥461 in realized P/L. GateGrid AI won four of its seven closed trades, giving it a 57.1% win rate, but the payoff ratio was only 0.28. Its winners averaged ¥53, while its losers averaged about ¥189. The final -¥296 loss made me stop for a moment; several small wins had done almost nothing to prepare the account for that exit.LLMBridgeTrader also finished negative, but its loss structure looked different. It lost two of three closed trades, yet its payoff ratio was 0.96 and the final loss was cut at just -¥11. That does not make the day good, but it suggests that the position-management layer was at least willing to abandon a weak idea.BoundSniper Bot and ML_ScoreAnalyst recorded no closed trades. MAribbonTrader opened one GBPCAD position, which remained open with an unrealized loss of ¥17 at the report cutoff.Bot-by-bot results■ GateGrid AI -356 yenRecord: 4W / 3LWin rate: 57.1%Gross profit: +212 yenGross loss: -568 yenPayoff ratio: 0.28Max loss: -296 yen■ LLMBridgeTrader -105 yenRecord: 1W / 2LWin rate: 33.3%Gross profit: +97 yenGross loss: -202 yenPayoff ratio: 0.96Max loss: -191 yenSwap included: +6 yen■ BoundSniper Bot 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ ML_ScoreAnalyst 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ MAribbonTrader 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax realized loss: 0 yenOpen positions: 1Unrealized P/L: -17 yen■ Total -461 yenRecord: 5W / 5LWin rate: 50.0%Gross profit: +309 yenGross loss: -770 yenPayoff ratio: 0.40Max loss: -296 yenUnrealized P/L excluded: -17 yenToday’s theme: the model can choose an entry, but the exit decides the damageThese five bots do not make decisions in the same way.BoundSniper Bot does not predict the market at all. It receives TradingView signals through a webhook and delivers them to MT5. ML_ScoreAnalyst uses a CatBoost score to filter GBPJPY breakout candidates. GateGrid AI is designed as a multi-stage system, using a quantitative gate before asking a local LLM to evaluate volatility, trend, session conditions and grid settings.LLMBridgeTrader gives the AI more freedom. It can propose BUY, SELL or NONE, but it can also choose OPEN, HOLD, CLOSE or REVERSE. It produces confidence, setup type, stop distance, profit target and reasons for entering or exiting. MAribbonTrader goes further into discretionary territory by asking Qwen to read a chart image containing moving-average ribbons, higher-timeframe context, support and resistance, range boxes and channel information.That makes the exit question especially important. An LLM can produce a convincing reason to remain in a position. It can also produce a convincing reason to close it. Only the realized trade tells us whether that flexibility protected the account or merely delayed the loss.The broker statement gives us the actions and outcomes, but not the bots’ internal decision logs. We can see when a position was opened and closed, yet we cannot verify the confidence score, setup classification or written exit reason that led to each action. That missing link matters. The next review should compare the model’s stated reason with the eventual P/L, rather than judging the model only from the broker report.GateGrid AI: the win rate hid an expensive loss structureGateGrid AI closed seven trades on EURUSD during the day. The design memo describes the bot as a GBPUSD system, so either the live configuration has changed or the running instance differs from the documented setup. It is worth recording that configuration change because symbol selection can alter volatility, spread and grid behavior.The first closed position lost ¥67. Two later long positions produced gains of ¥102 and ¥7. Another pair of short positions returned ¥98 and ¥5. At that stage, the sequence probably felt under control.The final two shorts changed the entire result. They were closed together for losses of ¥205 and ¥296.This is the weak point in the day’s result. Four winning trades produced only ¥212 in total, while three losing trades removed ¥568. The bot did not need a higher win rate. It needed either smaller losing exits or more room for the profitable layers to run.GateGrid uses filters before entry, including CatBoost probabilities, session thresholds, ATR conditions and a local Ollama judgment. Those filters may have done their job by selecting several trades that moved in the expected direction. The account still lost because the exit distribution was asymmetric in the wrong direction.The most useful log review is not simply “Why did the bot sell?” It is “Why were the last two positions still being held when their combined loss passed the total value of all four winners?” The answer is probably in the grid-closing or continuation logic, though the broker statement alone cannot prove it.LLMBridgeTrader: a losing day, but a more balanced exit profileLLMBridgeTrader closed three positions for a net realized result of -¥105.The first was a carried position that closed for -¥197 in trading P/L, partly offset by +¥6 in swap. The net loss was therefore ¥191. A new short was then opened at 10:30 and closed eight minutes later for a ¥97 gain. In the afternoon, a long position was opened and abandoned about fourteen minutes later for an ¥11 loss.That last exit is small, but it matters. I saw the -¥11 and thought this is at least the kind of failed idea the account can absorb.The bot’s win rate was only 33.3%, yet its payoff ratio reached 0.96. Average profit and average loss were nearly balanced, unlike GateGrid’s 0.28 ratio. The larger carried loss still dominated the day, but the newer intraday decisions did not show the same pattern of taking tiny gains while tolerating oversized losses.Because LLMBridgeTrader can return HOLD, CLOSE or REVERSE, its quality cannot be measured only at entry. The model must recognize when the original premise has weakened and switch from explanation mode to exit mode. The quick closure of the final long suggests that this transition happened, although the internal reason log is needed before calling it a repeatable improvement.The question for this bot is not whether the AI can describe a good setup. It is whether its confidence falls quickly enough when reality stops matching that description.BoundSniper Bot: no result to judgeBoundSniper Bot recorded no closed trades in the supplied report.That is not automatically a weakness. This bot is an execution bridge rather than a market forecaster. Its performance depends on whether TradingView produced a signal and whether the webhook, tunnel and MT5 execution chain delivered it correctly.With no trades, there is no payoff ratio or exit behavior to evaluate. The useful checks are operational: whether alerts were generated, whether webhook events arrived, whether any orders were rejected and whether the absence of trades was intentional.ML_ScoreAnalyst: the filter stayed inactiveML_ScoreAnalyst also recorded no trades.The system uses CatBoost to score GBPJPY breakout candidates and enters only when the score exceeds its threshold. A no-trade day may mean that no valid candidate appeared, or that candidates remained below the entry threshold.The broker statement cannot distinguish between those possibilities. The score log should show whether the bot spent the day returning NONE or actively rejecting low-scoring setups. Both lead to zero trades, but they say different things about the model.MAribbonTrader: the exit test is still openMAribbonTrader opened one 0.01-lot GBPCAD buy at 1.87744. At the report cutoff, the market price was 1.87729 and the position showed an unrealized loss of ¥17.The trade had a stop at 1.87433 and a target at 1.88175. It had not reached either level, so there is no closed result to score. Its realized P/L remains zero.This is the bot where the exit question may be most revealing. Qwen is being asked to interpret moving-average ribbons, higher-timeframe context, support and resistance, range conditions and channel structure. A chart-reading model can decide that a setup remains visually valid even while the position drifts against it.The next log should show whether the model continues to return HOLD, switches to EXIT before the stop, or lets the original risk plan play out. None of those choices is automatically correct. The value lies in whether the decision is consistent with the reason given at entry.Closing thoughtsA 50% portfolio win rate sounds neutral. A 0.40 payoff ratio is not neutral.July 24 showed how easily a few modest winners can create the feeling that a system is working while one exit sequence does most of the financial damage. GateGrid’s filters may have selected acceptable entries, and LLMBridge may have produced sensible short-term reactions, but the account was still governed by the size of the losing exits.The next improvement should not be another entry filter added on top of the existing ones. I would first connect every CLOSE, HOLD and forced stop to the model’s recorded reason. A bot that can explain why it entered is interesting. A bot that notices when its own explanation has expired is useful. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

ConclusionJuly 23 ended with a realized profit of ¥574 across the five-bot lineup. Only three bots had closed trades in the supplied account statements, but two of them did enough: LLMBridgeTrader earned ¥398 and MAribbonTrader added ¥201, while GateGrid AI finished slightly negative at ¥25.What caught my attention was not just the total. Several exits marked as stop-loss orders still closed in profit. That suggests the protective exit layer was doing more than limiting damage; it was also preserving gains after the market had already moved in the bot’s favor.LLMBridgeTrader still held one EURUSD- short position at the end of the report with an unrealized loss of ¥38. That floating result is not included in the ¥574 realized total.Bot Performance■ LLMBridgeTrader +398 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +644 yenGross loss: -246 yenPayoff ratio: 0.65Max loss: -246 yen■ MAribbonTrader +201 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +201 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ GateGrid AI -25 yenRecord: 8W / 3LWin rate: 72.7%Gross profit: +358 yenGross loss: -383 yenPayoff ratio: 0.35Max loss: -197 yen■ BoundSniper Bot ±0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/A■ ML_ScoreAnalyst ±0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/A■ Total +574 yenRecord: 14W / 4LWin rate: 77.8%Gross profit: +1,203 yenGross loss: -629 yenPayoff ratio: 0.55Max loss: -246 yenToday’s Theme: A Stop Is Not Always a Losing ExitThe account statement contains a useful detail. Four profitable LLMBridgeTrader exits were recorded with stop-related comments, and MAribbonTrader also closed its second trade through a stop-tagged order while still banking ¥41.That ¥41 exit looked modest, but I liked it. A stop that closes above the original entry is no longer just an emergency brake. It becomes a mechanism for turning open profit into realized profit before the market has time to take it back.The exact model reasoning is not included in the broker statement, so I cannot tell whether each stop adjustment came directly from the LLM, a trailing rule, or another risk-management layer. The execution result is clear, though: the profitable bots were able to leave the market with money still on the table.LLMBridgeTrader: Four Winning Exits Absorbed One Full LossLLMBridgeTrader produced five completed EURUSD- trades: +¥261, +¥88, +¥131, -¥246, and +¥164. Seeing +¥398 from only five closed positions was the first number that made me pause.The bot’s design gives the AI a wide decision space. It can propose BUY, SELL, or NONE, select OPEN, HOLD, CLOSE, or REVERSE, and return confidence, setup type, stop distance, target distance, and reasons for entry or exit. Risk checks then decide whether that plan is acceptable.The day was not flawless. Its single ¥246 loss was also the largest loss across all five bots, and the payoff ratio was only 0.65. The average winning trade was smaller than the losing trade, so the result depended on maintaining a high hit rate.Still, the sequence recovered well. Three early winners built ¥480, the loss removed ¥246, and the following ¥164 winner restored the daily result to ¥398. The exit process did not freeze after taking a hit, which matters for a system allowed to reassess positions through an LLM.MAribbonTrader: Two Shorts, Two Profitable ClosuresMAribbonTrader completed two GBPCAD- short trades and won both. The first reached a take-profit exit for ¥160, while the second closed through a stop-tagged order for another ¥41.This bot gives Qwen a chart image containing the short- and long-term MA ribbons, higher-timeframe context, support and resistance areas, range boxes, crossings, and channel information. The model then returns WAIT, BUY, SELL, or EXIT together with its reasoning.Two trades are far too few to prove an edge, and the payoff ratio cannot be calculated because there were no losing trades. Even so, this is the kind of small sample I would rather see: limited activity, no forced entry, and profit retained on both positions.The second trade is the more interesting one for the experiment. It did not need to reach its original target to contribute. The exit layer found a way to close positively, although the broker report alone does not reveal whether that came from the visual model’s judgment or a mechanical stop update.GateGrid AI: Gross Profit Was There, but the Exit Leakage Was LargerGateGrid AI won eight of eleven closed trades and generated ¥358 in gross profit. On win rate alone, the day looked healthy. The problem was that three losses totaled ¥383, leaving the bot down ¥25.The ¥197 loss was the one that bothered me. With an average win of only ¥44.75 and an average loss of roughly ¥127.67, the payoff ratio fell to 0.35. The bot needed almost three average winners to recover one average loss.Before the last two exits, GateGrid AI was ahead by ¥161. The final two closures lost ¥43 and ¥143, removing ¥186 and turning a profitable session into a small negative one. Its entry filters found enough favorable movement to create real gross profit, but the closing sequence gave slightly more back.GateGrid AI uses CatBoost as a quantitative gate before passing selected situations to Ollama. The local LLM then considers items such as spread, ATR, higher-timeframe trends, session, grid width, and recent performance. The broker statement does not contain the AI_SKIP, OLLAMA_HOLD, or decision-reason logs, so this report can evaluate the trade outcomes but not the exact rationale behind each entry.There is also a logging detail worth checking. The system description identifies GateGrid AI as a GBPUSD strategy, while the supplied account statement shows EURUSD-. For this article, I have followed the live account statement.BoundSniper Bot and ML_ScoreAnalystNo closed trades from BoundSniper Bot or ML_ScoreAnalyst appeared in the supplied statements. I have therefore recorded both as flat for this daily comparison rather than assuming anything about their broader operational status.BoundSniper is primarily an execution bridge. It carries TradingView signals through a webhook and local server into MT5, so its value is measured not only by strategy profit but also by execution accuracy, logging, and the absence of missed or duplicated orders.ML_ScoreAnalyst uses a CatBoost score to filter GBPJPY breakout candidates. Since there were no trades to evaluate, the useful evidence for this day would be its skipped signals and score distribution, but those logs were not included in the account report.SummaryThe profitable side of July 23 came from two different AI designs. LLMBridgeTrader used a broad trade-planning framework and recovered after one large loss, while MAribbonTrader took only two positions and kept both positive.GateGrid AI also found profitable moves, but its gross profit did not survive the full exit sequence. That contrast is useful. Entry quality created the opportunity, but the bots that finished ahead were the ones that converted open movement into closed profit.The next step is to connect each broker-side exit with its model output, confidence, decision reason, and stop update history. I do not just want to know which bot made money. I want to know whether the way it kept that money can be reproduced. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

The five-bot run finished at **-221 yen**, even though the closed trades produced four wins and only two losses. The combined win rate was 66.7%, but the payoff ratio was just 0.27. That gap tells the story better than the hit rate does.GateGrid AI posted the largest loss at -351 yen. MAribbonTrader won two of its three trades, yet one -125 yen stop erased the +101 yen collected from the first two. LLMBridgeTrader showed the opposite pattern: its EURUSD short was closed through a stop mechanism after moving into profit, leaving +130 yen behind. The entries mattered, but the day was decided by how each bot stopped holding.Bot-by-Bot Results■ GateGrid AI -351 yenRecord: 0W / 1LWin rate: 0.0%Gross profit: 0 yenGross loss: -351 yenPayoff ratio: N/AMax loss: -351 yen■ BoundSniper Bot +24 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +24 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ LLMBridgeTrader +130 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +130 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ ML_ScoreAnalyst 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yenNote: No daily trade report was supplied.■ MAribbonTrader -24 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +101 yenGross loss: -125 yenPayoff ratio: 0.40Max loss: -125 yen■ Total -221 yenRecord: 4W / 2LWin rate: 66.7%Gross profit: +255 yenGross loss: -476 yenPayoff ratio: 0.27Max loss: -351 yen## Today’s Theme: The Moment a Bot Stops HoldingA win rate can describe how often a decision worked, but it cannot explain how much damage was done when it failed. July 22 made that distinction hard to ignore. Four winning trades averaged 63.75 yen, while the two losses averaged 238 yen.For the LLM-driven bots, the interesting question is not only whether the model selected the correct direction. It is whether the bot knew when the original idea had weakened enough to close, trail, or reverse. An entry model can be slightly wrong and survive. An exit process that stays passive for too long can turn one mistake into the entire day’s result.GateGrid AIGateGrid AI opened an EURUSD short at 1.13997 and closed it at 1.14212 roughly twelve hours later. The result was -351 yen, the largest single loss of the day. I paused at that number because it outweighed every profitable trade from the other bots combined.The design notes describe GateGrid AI as a multi-stage system using CatBoost, local LLM judgment, volatility checks, time filters, and trailing management. The daily broker report alone does not reveal which gate approved this entry or why the position remained open. It also shows EURUSD, while the intended configuration describes GBPUSD, so the live symbol setting deserves a separate check.The immediate issue is the exit path. A filtered entry is useful only if the system can recognize when the approved setup is no longer valid. The next review should match the broker timestamps against the CatBoost score, Ollama response, ATR state, trailing-stop updates, and any hold decision recorded during the position.BoundSniper BotBoundSniper entered a USDJPY long at 163.067 and closed it one minute later at 163.091 for +24 yen. It was a small trade, but the execution chain appears clean: the TradingView instruction reached MT5, the position opened, and the exit followed without a visible operational error.This bot does not predict the market itself, so its result should not be judged like an LLM strategy. Its job is faithful delivery. The useful questions are whether the correct signal was received, whether latency or spread altered the intended price, and whether the exit command was executed once without duplication.There is no meaningful payoff ratio from one winning trade and no losing sample. Still, the trade did what an execution bridge is supposed to do, which matters more than trying to turn +24 yen into a larger claim.LLMBridgeTraderLLMBridgeTrader sold EURUSD at 1.14172 and closed at 1.14092 for +130 yen. The closing comment indicates a stop-based exit, suggesting that the protection level had moved into profitable territory or was otherwise used to lock in the favorable move.This was the most convincing exit of the day. The bot did not need to catch the entire decline. It converted an open gain into a realized result and avoided letting the trade drift back through the entry.The report does not include the model’s confidence, setup label, original SL/TP proposal, or decision text, so it cannot prove whether the LLM itself initiated the final exit. Those logs matter. Still, the live outcome shows a useful separation between AI planning and mechanical protection: the model can propose the trade, while the system makes sure a favorable position does not remain unprotected.ML_ScoreAnalystNo July 22 trade report was included for ML_ScoreAnalyst. I have recorded it as zero closed trades rather than assuming that the bot was inactive.That distinction matters. A score-based bot may correctly skip an entire day because no candidate cleared its threshold, or it may simply have a missing report. The signal log is needed to tell whether the day consisted of valid SKIP decisions, no breakout candidates, a stopped process, or a reporting gap.For this bot, no-trade days are part of the experiment. They become informative only when the candidate score and rejection reason are retained.MAribbonTraderMAribbonTrader completed three GBPCAD shorts. The first two earned +38 yen and +63 yen. The third lost -125 yen, leaving the bot at -24 yen despite winning two of three trades.That loss felt familiar: two correct reads, then one trade large enough to take them both back. The payoff ratio was 0.40 because the average winner was 50.5 yen and the average loser was 125 yen. A 66.7% win rate looks comfortable until that ratio is placed beside it.The final trade was stopped about nine minutes after entry, so this was not a case of holding for hours without protection. The harder question is whether the initial risk was too large relative to the profit the bot usually accepts. If winners are routinely closed around 38 to 63 yen, a 125 yen loss requires an unusually high hit rate just to stay level.Because MAribbonTrader delegates chart interpretation and exit reasoning to AI, its SQLite logs should be used to compare the three trades. The review needs the ribbon state, H4 context, support and resistance, channel room, entry explanation, and exit explanation. The cause may be the stop width, or it may be that the third setup should have been rejected before entry. The broker statement cannot settle that yet.SummaryThe day did not expose a shortage of winning signals. It exposed an imbalance between what the bots were willing to take as profit and what they were willing to surrender when wrong.LLMBridgeTrader left the cleanest clue by protecting a profitable short. MAribbonTrader showed why a respectable hit rate can still leak money, while GateGrid AI showed how one unresolved position can dominate a multi-bot portfolio. The next improvement may not be another entry filter. It may be teaching each bot to notice sooner when staying in the trade has become the risk. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

The day after a loss, every strategy appears easy to improve.The stop was too wide.The entry was too early.The session was wrong.The filter was too weak.There is always something that could have prevented the latest losing trade.So we change it.The next trade loses too.We change something else.Eventually, the strategy has been modified so many times that we can no longer explain what improved or what failed.We wanted a better system.We removed the evidence needed to understand the original one.Change feels like progressDoing nothing during a drawdown feels irresponsible.The account is declining.The same rules are still running.The trader feels expected to act.So the stop is tightened.Another indicator is added.The trading window is reduced.A new market-regime filter is introduced.Editing the code provides immediate relief.The system looks more protected.At least something has been done.But emotional relief and strategy improvement are not the same thing.A change designed to reduce discomfort may not improve long-term performance.Losses do not arrive on scheduleStrategy losses may be distributed over hundreds of trades in a test.Live trading does not deliver them evenly.Several losing trades may arrive together.Different bots may fail during the same market transition.What was expected to occur across several months can appear inside one week.Leverage makes this concentration feel even more significant.At small size, the week may look like ordinary variance.At larger size, it feels like structural failure.The market behavior is identical.The financial pain changes the diagnosis.A trader may believe the strategy is being evaluated objectively while actually reacting to the size of the drawdown.One adjustment creates anotherSuppose a losing streak leads to a tighter stop.The new stop is reached by ordinary price movement.Loss frequency increases.The trader responds by adding stricter entry filters.Trade frequency falls too far.The session is expanded to create more opportunities.The expanded session introduces different spreads and price behavior.Another filter becomes necessary.The first adjustment was small.Its consequences created a chain of additional adjustments.Later, performance improves.Was it the tighter stop?The entry filter?The wider session?Or did the market simply return to a more favorable regime?Nobody knows.The strategy was improved in several places and made impossible to evaluate in any one place.Preserve the baselineTesting requires a comparison.Before and after.The same market.The same costs.The same sizing.The same time horizon.When several variables change together, the comparison disappears.A useful process preserves the original version.Keep one bot on the old configuration.Store the previous parameters.Write one sentence explaining why each change was made.Define the number of trades or amount of time required before judging it.Record what the new rule removes, including the winning trades it may also remove.Improvement is not only the act of adding a better rule.It is also the discipline of protecting the evidence needed to verify that the rule is better.I feel the same urge with trading botsI run several MT5 bots built around different approaches.Some are rule based.Some receive TradingView alerts.Some use machine-learning scores.Some include language-model judgment.After a losing day, the code looks full of obvious improvements.A condition could have avoided this trade.An earlier exit could have protected that profit.A different filter could have rejected the setup.Looking backward makes the answer appear clear.But a rule designed to avoid one historical loss may remove profitable trades in another market.Avoiding a particular loss is not the same as improving the full distribution of outcomes.Without that distinction, a bot gradually becomes optimized for the chart that already happened.Diagnose before changingA negative P&L does not identify the broken component.The problem may be the entry.The direction was wrong, price was chased, or the setup did not fit the regime.It may be the exit.The stop was unsuitable, the strategy gave back profit, or it failed to respond to reversal evidence.It may be the size.The position was too large or several systems carried the same hidden exposure.It may be execution.Spread widened, orders were delayed, or retry logic behaved incorrectly.It may be the market environment.The strategy was designed for movement that was no longer present.The same financial result can come from different operational causes.Changing the full strategy before separating those causes often modifies the parts that were working.Reduce size before rewriting logicMaintaining the same rules during a losing period can still feel dangerous.A practical first response is to reduce size.This is not avoidance.It protects the ability to observe.At full exposure, each result carries more emotional force.Normal variance feels unacceptable.The need to recover becomes stronger.Parameter changes become more urgent.Smaller size reduces the financial pressure without immediately changing the system being evaluated.The strategy can continue producing evidence.Losses have less impact on the account.A favorable regime can return without the original logic having been removed.During a drawdown, the first goal is not always to find the answer immediately.It may be to preserve enough capital and mental space to recognize the answer later.Doing nothing still requires a plan“Do nothing” can become a dangerous excuse.A genuinely broken strategy can be allowed to continue under the label of patience.Observation needs boundaries.For example:Keep the logic unchanged for the next twenty trades.Run at half size.Record entry, exit, spread, session, and execution quality.Separate rule-following losses from operational failures.Stop if the drawdown exceeds a predefined limit.After the observation window, select only one modification to test.This is not passive neglect.It is a controlled period in which changes are delayed so that evidence can remain comparable.Useful improvements are often boringStrategy improvement is often associated with major additions.A new AI model.A new indicator.A new entry engine.A new market.In production, the most valuable changes may be less dramatic.Rejecting trades during excessive spread.Improving retry logic.Preventing duplicate exposure.Writing better logs.Defining restart conditions.Correcting position-size calculations.Each change is small.None creates a completely new strategy.Together, they remove repeated operational mistakes.A modest improvement that remains active for years may contribute more than a sophisticated idea that is replaced after the next drawdown.Activity is not evidence of improvementA large amount of work can be completed without making the strategy better.More code.More backtests.More parameters.More filters.The useful questions remain:What improved relative to the original?Did it improve in unseen periods?Does the result survive transaction costs?Which profitable trades were removed?Can the change be explained and repeated?Changing a strategy is easy.Keeping it unchanged long enough to learn from it is harder.That waiting period is not wasted time.It is what makes the next adjustment interpretable.The same pattern appears outside tradingA newsletter fails to grow, so the topic changes.A product receives little attention, so new features are added.A study method feels slow, so another course is purchased.Changing the method produces a sense of movement.But when the method changes before results have enough time to appear, no learning accumulates.Improvement requires adjustment.It also requires periods of stability.Without stable periods, the effect of each adjustment remains invisible.Preserve before you repairThere is no perfect trading strategy.Losses cannot be removed completely.Unexpected clusters will occur.Rebuilding the system after each one prevents the strategy from developing a reliable history.The answer is not to ignore poor results.It is to slow the rate of change when poor results create the strongest urge to act.Reduce size.Separate the causes.Keep the logs.Preserve the baseline.Change one variable.Wait long enough to observe the result.Before repairing the strategy, protect the process that allows you to learn what needs repair.Is the next adjustment truly designed to improve the system?Or is it mainly designed to make the latest loss feel easier to live with? This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

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

ConclusionThe five-bot portfolio finished July 17 at -1,362 yen realized, with another -175 yen unrealized on an open ML_ScoreAnalyst position. The combined mark-to-market result was therefore -1,537 yen.The loss itself is not the most useful part of the record. Exit structure separated the bots far more clearly than entry style did. MAribbonTrader won only one of two trades, yet ended positive because its average winner was 1.74 times its average loser. GateGrid AI, LLMBridgeTrader, and ML_ScoreAnalyst produced seven losing closes between them without a single winner to absorb the damage.The -602 yen stop on ML_ScoreAnalyst made me pause. It was not an unusual malfunction; it appears to be the intended fixed-stop design doing exactly what it was told to do. That may be more uncomfortable than a software error, because it points back to the payoff geometry itself.Bot-by-Bot Results■ GateGrid AI -393 yenRecord: 0W / 3L (Win rate 0.0%)Gross profit: 0 yenGross loss: -393 yenPayoff ratio: Not availableMax loss: -252 yen■ BoundSniper Bot +10 yenRecord: 1W / 0L (Win rate 100.0%)Gross profit: +10 yenGross loss: 0 yenPayoff ratio: Not availableMax loss: 0 yen■ LLMBridgeTrader -479 yenRecord: 0W / 2L (Win rate 0.0%)Gross profit: 0 yenGross loss: -485 yenSwap: +6 yenPayoff ratio: Not availableMax loss: -290 yen■ ML_ScoreAnalyst -602 yen realizedRecord: 0W / 1L (Win rate 0.0%)Gross profit: 0 yenGross loss: -602 yenPayoff ratio: Not availableMax loss: -602 yenOpen P/L: -175 yen■ MAribbonTrader +102 yenRecord: 1W / 1L (Win rate 50.0%)Gross profit: +240 yenGross loss: -138 yenPayoff ratio: 1.74Max loss: -138 yen■ Total -1,362 yen realizedRecord: 2W / 7L (Win rate 22.2%)Gross profit: +250 yenGross loss: -1,618 yenSwap: +6 yenPayoff ratio: 0.54Max loss: -602 yenOpen P/L: -175 yenResult including open P/L: -1,537 yenToday’s Theme: An Entry Filter Cannot Rescue a Weak ExitThese five bots do not make decisions in the same way. BoundSniper relays TradingView instructions. ML_ScoreAnalyst scores a setup with CatBoost. GateGrid AI adds several entry gates before allowing a trade. LLMBridgeTrader lets an LLM choose OPEN, HOLD, CLOSE, or REVERSE. MAribbonTrader asks a local model to read chart structure and then trades around that interpretation.Despite those differences, the day converged on one issue: what happened after entry.A bot can reject mediocre setups, score a breakout correctly, or produce a persuasive market explanation. None of that guarantees a durable result if the position is held until a distant fixed stop, if reversal handling creates overlapping exposure, or if the model does not abandon its original thesis soon enough.The useful experiment is no longer just “Did the model pick the right direction?” It is “What information was available when the trade should have been closed, and what did the bot decide to do with it?”GateGrid AI: Multiple Gates, but the Exit Sequence Still HurtGateGrid AI closed three losing GBPUSD trades for -393 yen. The first short was opened at 1.34598 and covered at 1.34753 for -252 yen. That was the largest loss inside this bot.The later sequence deserves more attention. A buy was filled at 1.34762, then a sell was filled at 1.34681. Both sides were closed at 10:17, producing losses of -130 yen and -11 yen. The record shows simultaneous opposing exposure and an immediate flattening sequence. That looks less like a simple bad directional call and more like a coordination problem around reversal, hedging, or grid shutdown.GateGrid’s CatBoost and Ollama layers are designed to be selective before entry. On this day, the missing evidence is what happened after those gates opened. The next log review should align the model score, Ollama response, active grid state, close trigger, and any reversal flag on the same timeline. Without that, tuning the entry threshold would be guesswork.BoundSniper Bot: The Bridge Worked, but One Tiny Win Proves LittleBoundSniper opened a USDJPY short at 162.255 and closed it 45 seconds later at 162.245 for +10 yen. The trade was clean, fast, and profitable.That is encouraging from an execution perspective. The TradingView instruction reached MT5, the position was opened, and the exit was transmitted without a visible operational failure. Since BoundSniper does not create the market thesis itself, this is exactly the part of the system it needs to perform well.Still, a 100% win rate from one trade is mostly decoration. There was no losing trade, so the payoff ratio cannot be calculated. The result says the bridge functioned; it does not yet say the upstream TradingView strategy has an edge.LLMBridgeTrader: The LLM Had Control of the Exit, but the Hard Stop Did the WorkLLMBridgeTrader finished at -479 yen after swap. One position closed for -290 yen, while a later EURUSD short lost -195 yen.The second trade is the cleaner test because both entry and exit appear in the day’s report. The bot sold at 1.14275 at 14:00 and exited at 1.14395 at 17:17. The position remained open for more than three hours and eventually closed at the stop level.This bot is allowed to return HOLD, CLOSE, or REVERSE. That makes the exit path the central part of the experiment. Yet the live result looks no more adaptive than a trade held until a mechanical stop. I cannot say the LLM ignored an obvious exit without seeing its decision logs, but the record gives no sign that its broader authority improved the outcome.For the next review, every HOLD decision should be stored with current unrealized P/L, recent price structure, confidence, and the reason the model rejected CLOSE. The most valuable training examples may be the moments when the model kept defending a position that later stopped out.ML_ScoreAnalyst: The Model Score Is Only Half the BetML_ScoreAnalyst bought GBPJPY at 218.605 and was stopped at 218.003 for -602 yen. It then opened a new short that remained active at the end of the report with -175 yen unrealized.The closed loss is consistent with the bot’s roughly 60-pip stop setting. The profit target is around 25 pips. That structure needs a win rate of about 70.6% before trading costs just to break even. A scoring model can be directionally useful and still struggle under that burden.This is why the -602 yen loss matters beyond one bad trade. It is the natural consequence of a design where one full stop requires more than two normal target wins to repair. Raising the CatBoost threshold may reduce weak entries, but threshold tuning alone will not fix an unfavorable payoff profile.The open short also matters. Realized performance was -602 yen, but actual end-of-day exposure made the bot’s contribution -777 yen on a mark-to-market basis. The next test should compare the existing 60/25 structure with volatility-adjusted exits and a less asymmetric fixed alternative.MAribbonTrader: A 50% Win Rate Was EnoughMAribbonTrader was the most balanced result of the day. Its first GBPCAD short earned +240 yen. Its second short lost -138 yen. The final result was +102 yen with a 50% win rate and a payoff ratio of 1.74.That is the cleanest exit profile in the group. The winner was allowed to reach its target, while the loser remained smaller than the prior gain. The second loss included some slippage around the stop, but it did not erase the first trade.Two trades are not enough to validate chart-reading intelligence. The model may have read the MAribbon context well, or it may simply have landed on a favorable pair of trades. What can be said from the execution record is narrower and more useful: the exit geometry gave the bot room to survive an ordinary loss.For this bot, the next layer of analysis should connect each result to the image prompt, the detected ribbon state, the model’s WAIT or entry rationale, and the reason for exit. The positive result is welcome, but the reusable evidence lives in those logs.SummaryThe portfolio’s 22.2% win rate was weak, but the deeper issue was the total payoff ratio of 0.54. Gross profits reached only +250 yen against -1,618 yen in gross losses. A system cannot filter its way out of that imbalance forever.The next improvement should be built around exit snapshots rather than another round of entry optimization. For every open position, the bots need a record of maximum favorable excursion, maximum adverse excursion, model confidence, exit recommendation, and the reason a close was postponed. That would show whether losses came from poor entries, slow recognition, rigid stops, or confused reversal handling.Bots reveal their real character after they are already in the market. July 17 made that part unusually visible. 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

Looking back at the operating logs of the AI trading bots on July 15 and 16, a clear and somewhat painful theme has emerged. It is the reality that “the timing of the exit (closing a position) is far more important than the frequency or accuracy of the entry.”The Illusion of Win Rate and the Payoff Ratio (Lessons from July 15)On July 15, we ran four MT5 bots, ending the day with a total loss of -1,456 JPY.Some bots recorded a 50% win rate that day, yet the account balance still decreased. Overall, the record was 6 wins and 8 losses (a 42.9% win rate), meaning they were not losing excessively. The bots were not wildly misjudging the market direction all day.The problem was that they were “paying too much when they were wrong.” The payoff ratio was only 0.51, meaning the average profit was only half the size of the average loss. Even if small profits are accumulated, a single loss, inflated by a delayed exit, can wipe them all out. Faced with such results, the “win rate” metric feels like mere noise.AI’s Struggle and the Victory of Simplicity (Lessons from July 16)On the following day, July 16, we ran five bots, including the newly added MAribbonTrader. The realized profit and loss was -464 JPY.On this day, the difference in the bots’ “approaches” clearly divided the results. The most outstanding performer was, ironically, the least “conversational” bot, ML_ScoreAnalyst. Without hesitation, this system successfully hit the take-profit on both of its two trades, generating a profit of +502 JPY on its own.In contrast, the bots that relied on LLMs (Large Language Models) or image recognition AI for judgment struggled with “cutting losses,” “switching positions,” and “staying out of the market.” The decision of whether to “HOLD” or “CLOSE” a position after entering proved to be the most costly challenge.Behavior and Challenges of Each BotOver these two days, the different risks associated with each of the five bots became apparent.* GateGrid AIOn the 15th, despite a 50% win rate, delayed exits made the trades too costly, resulting in a loss. On the 16th, it showed inexplicable behavior, closing a trade in the same second it was opened, resulting in a -13 JPY loss. While the entry filter is functioning, a detailed log review of the handoff between execution and closing is necessary.* BoundSniper BotThis is a rule-based bot that executes signals received from TradingView. It had a 50% win rate on the 15th, but on the 16th, it suffered seven consecutive losses after one win, dropping its win rate to 12.5%. The issue is not the execution engine itself; improving the quality of the upstream signals and revising the exit rules during losing streaks is urgently needed.* LLMBridgeTraderOn the 15th, despite a 33.3% win rate, it limited its losses and showed a decent structure with a payoff ratio of 1.23. However, on the 16th, immediately after a loss, it quickly took a position in the opposite direction and held an unrealized loss (-145 JPY). Measures are needed to prevent delayed withdrawals and overreaction (chasing) after a loss.* ML_ScoreAnalyst (formerly MLScore GF-T4)On the 16th, it successfully took profit on two GBPJPY long trades, achieving a commendable result of +502 JPY. However, on the 15th, it had a record of “a winning trade of +300 JPY and a losing trade of -599 JPY,” revealing the issue of its stop-loss being too wide. We must continue to evaluate the “true cost” of this wide stop-loss, rather than just trusting clean wins like those on the 16th.* MAribbonTraderThis bot, which uses image recognition AI to read charts, held a position for over 12 hours on the 16th, resulting in the largest single loss of the day (-447 JPY). The market context must have changed during that long holding period, making it necessary to verify whether the exit mechanism is functioning properly.Next Steps: Towards Exit DisciplineIn live automated trading, what protects the day’s profits is the decision that “I will not hold this position any longer.” The results of these tests teach us that future system improvements should focus on “exit discipline” rather than “entry confidence.”In the next iteration, we will implement the following changes:* Detailed State Logging: Record the position direction, unrealized P/L, model confidence, and the reason for the decision (e.g., HOLD or CLOSE) as a compact log to make the validity of the closing decision verifiable.* Review Maximum Holding Time: Set re-evaluation triggers based on elapsed time to reduce the risks associated with holding positions for a long time.* Introduce Cooldowns: Prevent immediate entries right after a loss is finalized, separating genuine trend reversals from “emotional chasing.”Systems equipped with advanced AI models have, ironically, left us with the most human and difficult question of “when to exit.” However, these clear differences between the systems and the records of their failures are precisely the most valuable data we need to push them to the next level. 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

ConclusionClosed trades finished at +1,103 yen across the four bots. That sounds clean at first glance, and part of me wanted to leave it there. But BoundSniper carried an open floating loss of -641 yen, which pulled the effective result down to +462 yen. I paused at that number, not because it was disastrous, but because it reminded me how easily a good-looking day can become an exit problem.The entries were not the main story today. GateGrid AI and MLScore GF-T4 GB did their job, LLMBridgeTrader struggled, and BoundSniper did not close at all. The lesson is uncomfortable but useful: when an LLM or an automated system is allowed to decide whether to keep holding, the exit logic deserves as much attention as the entry signal.Bot-by-bot results■ GateGrid AI +852 yenRecord: 11W / 1LWin rate: 91.7%Gross profit: +1,006 yenGross loss: -154 yenPayoff ratio: 0.59Max loss: -154 yenFloating P/L: 0 yen■ BoundSniper 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: N/AFloating P/L: -641 yen■ LLMBridgeTrader -266 yenRecord: 2W / 3LWin rate: 40.0%Gross profit: +116 yenGross loss: -382 yenPayoff ratio: 0.46Max loss: -196 yenFloating P/L: 0 yen■ MLScore GF-T4 GB +517 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +517 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/AFloating P/L: 0 yen■ Total +1,103 yen realizedRecord: 15W / 4LWin rate: 78.9%Gross profit: +1,639 yenGross loss: -536 yenPayoff ratio: 0.82Max closed loss: -196 yenFloating P/L: -641 yenEffective P/L: +462 yenToday’s themeToday was a reminder that win rate can flatter the system. The total win rate was 78.9%, which looks strong, and GateGrid AI alone printed 11 wins from 12 exits. Still, the combined payoff ratio was only 0.82, so the average win was smaller than the average loss. That is not a fatal structure for a high-win-rate system, but it leaves less room for a single awkward hold.The bigger issue was the open position. BoundSniper had no closed result, so it looked harmless in realized P/L, yet its -641 yen floating loss was larger than every closed loss of the day. That is the part that made me stop and look twice. The damage was not booked, but it was already sitting there.GateGrid AIGateGrid AI was the strongest closed-trade performer today. It ended at +852 yen, with 11 wins and 1 loss, and the largest win was +424 yen. That single +424 yen trade helped cover a lot of smaller exits, and honestly it made the log feel safer than it really was for a moment.The weak point is the payoff ratio. At 0.59, the average win was still smaller than the average loss. GateGrid AI can survive that when the CatBoost gate, Ollama filter, ATR checks, session thresholds, and trailing management keep the win rate high. But if the entry filter loosens or the market starts chopping harder, that ratio can become a quiet problem.As an LLM/ML hybrid, GateGrid’s best behavior today was not just entering. It also exited without letting the one loss grow beyond -154 yen. That matters. For a grid-style bot, the real test is whether the model can stop building exposure when the setup gets stale, and today it mostly did.BoundSniperBoundSniper closed nothing today. On paper, the realized result is 0 yen, but the open EURUSD position was sitting at -641 yen by the report time. This is the number that changed the whole reading of the day. A flat realized result is not neutral when the position is still bleeding.BoundSniper is mainly an execution bridge for TradingView signals rather than a bot that predicts the market itself. That means the quality of the day depends heavily on whether the external signal provides a timely exit, and today the exit had not arrived by the cutoff. Maybe the strategy is built to hold through this kind of drawdown. I do not know that from this report alone, so I do not want to overstate it. Still, for live operation, the open-loss rule needs to be treated as part of the system’s score, not as an afterthought.LLMBridgeTraderLLMBridgeTrader had the most interesting failure pattern. It won twice, then gave back more than it earned through three losses. The final result was -266 yen, and the payoff ratio was 0.46. When I saw the -196 yen stop loss, I had the familiar reaction: this is probably not an entry-only issue.This bot gives the AI more responsibility. It can decide BUY, SELL, NONE, and also OPEN, HOLD, CLOSE, REVERSE, or NONE. That makes the exit decision central. Today, the losing trades suggest the model either held too long, changed its view too late, or accepted setups where the expected reward was too thin. I cannot prove the exact reason without the prompt log, but the shape points toward exit judgment and risk-reward filtering more than raw direction alone.The good side is that the losses were not uncontrolled. The max closed loss was -196 yen, not a runaway event. But the two wins were only +45 yen and +71 yen, so the bot needs either cleaner exit timing or a stricter rule that blocks trades when the likely reward is too small.MLScore GF-T4 GBMLScore GF-T4 GB did exactly what a small automated system needs to do on a quiet report: it took two closed wins and finished at +517 yen, including +13 yen swap. Both exits hit TP-style comments, and there were no open positions left at the cutoff.There is not enough detail in the report to make a deep claim about the model behind MLScore. I will keep this modest. The result was clean, the exits were clean, and unlike BoundSniper, it did not leave a floating problem behind. Some days that is enough.Wrap-upThe day was profitable, but not as comfortable as the closed P/L suggested. GateGrid AI and MLScore carried the board, LLMBridgeTrader exposed the cost of weak payoff structure, and BoundSniper reminded me that unrealized risk is still risk. The next thing I would check is not just which bot entered well, but which bot knew when the trade had stopped being worth holding.② Substack NoteFour MT5 bots finished July 14 with +1,103 yen in closed P/L, but the cleaner headline hides the real lesson.GateGrid AI and MLScore did the lifting. LLMBridgeTrader struggled with payoff. BoundSniper carried a -641 yen open loss, which made the effective result much smaller.Today was less about entry accuracy and more about exits. The trade that is not closed yet can still become the main story. 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

You can identify a reversal early and still lose the trade.Price makes a new high.Momentum fails to confirm it.The divergence looks clear.You sell.Price continues higher.You are stopped out.Another divergence appears.You sell again.The market keeps moving in the same direction.Eventually, the reversal may happen.But by then, your capital and patience may already be damaged.The warning was not necessarily wrong.You simply treated it as if the event had already happened.Weakening is not the same as reversingWhen price continues higher while momentum becomes weaker, something has changed inside the move.The trend may be losing energy.But losing energy does not mean the trend has ended.A car can slow down without stopping.It can stop without reversing.Momentum indicators can reveal that the current move is no longer as strong as it was.They cannot guarantee when price will turn.As long as buyers remain in control, price can continue making new highs even while momentum declines.Divergence identifies tension.It does not resolve it.The earlier the entry, the longer the fightCalling a top or bottom early is attractive.The potential reward is larger.The entry looks impressive after the reversal happens.But an early countertrend position must survive the part of the move that has not finished.Selling an active uptrend means holding while buyers are still in control.Buying an active downtrend means standing in front of sellers who have not stopped.Even if the final direction is correct, the trade can fail before the market proves it.Being early is not always different from being wrong from the account’s point of view.Let the warning change what you watchA divergence does not have to trigger an order.It can move the market into a higher-alert state.After bearish divergence in an uptrend, you might wait for:A break below a recent swing low.Failure to make another higher high.A clear break of trend structure.A weak recovery after the first decline.A candle close that confirms selling pressure.The exact trigger depends on the strategy and timeframe.The sequence matters more than the specific tool.Momentum identifies the warning.Price confirms the change.Risk determines whether the trade is worth taking.Confirmation has a costWaiting for confirmation means giving up part of the move.You will not sell the exact top.You will not buy the exact bottom.The entry may offer a smaller reward relative to the stop.That can feel inefficient.But early entry has costs too.Multiple stop-outs.Long periods of holding against the trend.The temptation to increase size because the reversal feels overdue.The mental strain of defending a prediction price has not confirmed.The choice is not between a perfect early entry and a late entry.It is between paying for confirmation with some lost distance, or paying for anticipation through additional uncertainty and failed attempts.Separate alerts from ordersThis distinction becomes especially useful in automated trading.A simple bot often turns every detected condition into an order.RSI reaches a threshold.Moving averages cross.Divergence appears.Buy or sell.The code is clean.The logic may be too compressed.In an MT5 bot, I would treat divergence as an alert layer.Then I would require separate confirmation from price structure.I would also check spread, trading session, and major-event restrictions before allowing an order.This creates more conditions and fewer trades.It also prevents one indicator from carrying responsibility it was never designed to handle.Detection and execution should be separate layers.Give every signal one jobWhen a strategy struggles, traders often add more indicators.RSI.MACD.Moving averages.Volume.Volatility filters.More information does not always create clearer decisions.It helps to assign each input a specific role.One tool identifies the market environment.Another detects weakening momentum.Another confirms entry.Another adjusts position size.Another stops the system.For example:The higher timeframe defines the trend.Divergence creates an alert.A swing break confirms the change.Spread and session rules permit execution.A drawdown limit stops trading.Not every indicator needs to answer buy or sell.Some signals are more useful when they only tell you what to watch next.A warning can still protect an open positionNot trading divergence does not mean ignoring it.A warning can change how you manage existing risk.You may avoid adding a new position.Take partial profit.Reduce size.Tighten operational oversight.Stop giving the trend unlimited benefit of the doubt.Divergence may be unreliable as a standalone entry.It can still be valuable as a reason to become more cautious.Between noticing and actingMarkets reward awareness.Seeing a change before it becomes obvious can be useful.But observation and execution are different skills.Something looks weaker.The move feels different.Momentum no longer supports price.That is the beginning of analysis, not the end.The next question is whether price has confirmed the change.Does your signal tell you that something may happen?Or does it tell you that it already has?Before turning a warning into a position, make sure you know which job the signal is doing. 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

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 GBThe 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 weekThe 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 profitThe 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 negativeThe 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 everythingThe 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 shortThe 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 profitGateGrid 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 tradesBoundSniper 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 daysThe 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 yenThe 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 dayMLScore 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 entryWhen 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 expiredEvery 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 rulesI 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 botLosing 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'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

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 AIWhile 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 RatioThe 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 JPYTrading 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 GBSuccessfully executed clean take-profits by precisely hitting pre-set targets (TP) twice, earning +483 JPY.* LLMBridgeTraderDespite 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 AIDespite 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.* BoundSniperSuffered 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'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

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 yenToday’s theme: the win count looked fine, the loss size did notToday 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 brokeGateGrid 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 damageBoundSniper 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 cleanLLMBridgeTrader 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 informationMLScore 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 thoughtsToday’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'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

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 yenToday’s theme: the bots did not just lose, they failed to stop the bleedingThere 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 recoveryGateGrid 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 lossBoundSniper 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 cutsLLMBridgeTrader 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 behindMLScore 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 thoughtsToday’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'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

ConclusionThe 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 invalidationToday’s, or rather this week’s, themeThis 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 AIGateGrid 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 BotBoundSniper 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.LLMBridgeTraderLLMBridgeTrader 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-T4MLScore 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.SummaryThe 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'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

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 yenToday’s theme: the entry was not the only decisionI 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 controlGateGrid 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 mathBoundSniper 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 remainsLLMBridgeTrader 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 TPMLScore 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 thoughtsToday’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'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

ConclusionThe 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 lossToday’s Theme: The Exit Was Louder Than the EntryToday 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 AIGateGrid 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.LLMBridgeTraderLLMBridgeTrader 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 GBMLScore 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.BoundSniperBoundSniper 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.SummaryThe 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'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

Four MT5 bot trade log for June 30, 2026The 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 yenToday’s themeToday 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 AIGateGrid 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 BotBoundSniper 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.LLMBridgeTraderLLMBridgeTrader 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 GBMLScore 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-upThe 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'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

ConclusionGateGrid AI won 8 out of 10 closed trades and still finished at -400 yen. That is the whole day in one line, and it is not a comfortable one. The bot kept collecting small wins, but one -729 yen loss cut through the sequence hard enough that I had to pause for a second.Across the four MT5 bots, the realized total came to -789 yen. The combined win rate was 60.9%, which does not look disastrous on paper, but the payoff ratio was only 0.36. That number says more than the win rate today: the average loss was simply too heavy compared with the average win.Bot-by-Bot Results■ GateGrid AI -400 yenRecord: 8W / 2LWin rate: 80.0%Gross profit: +394 yenGross loss: -794 yenPayoff ratio: 0.12Max loss: -729 yen■ BoundSniper +92 yenRecord: 3W / 1LWin rate: 75.0%Gross profit: +166 yenGross loss: -74 yenPayoff ratio: 0.75Max loss: -74 yenOpen P/L: -118 yen■ LLMBridgeTrader -318 yenRecord: 1W / 3LWin rate: 25.0%Gross profit: +55 yenGross loss: -379 yenPayoff ratio: 0.44Max loss: -243 yenOpen P/L: -86 yen■ MLScore GF-T4 GB -163 yenRecord: 2W / 3LWin rate: 40.0%Gross profit: +382 yenGross loss: -557 yenPayoff ratio: 1.03Max loss: -265 yen■ Total -789 yenRecord: 14W / 9LWin rate: 60.9%Gross profit: +997 yenGross loss: -1,804 yenPayoff ratio: 0.36Max loss: -729 yenOpen P/L: -204 yenToday’s ThemeThe theme today was not entry accuracy. It was exit quality. GateGrid AI had the best win rate of the group, but its payoff ratio was the weakest at 0.12. When a bot needs many small wins to cancel one large loss, the entry filter can look smart while the exit still quietly breaks the day.This is especially important for the bots where AI or model judgment is involved. I am not only testing whether an LLM can pick BUY or SELL. I am testing whether it can stop holding, switch to closing, or stay out before the position becomes expensive. Today, that boundary was not clean enough.Bot AnalysisGateGrid AI was the most painful case. The CatBoost and Ollama-style gate structure is built to avoid bad entries, and the 80.0% win rate suggests that the filtering was not useless. But the losses were uneven: one -729 yen exit erased eight wins that totaled only +394 yen. Looking at that -729 yen, I did not think “bad luck” first. I thought the trailing or stop transition probably stayed too loose for the later move, though I do not have full certainty from the daily report alone.BoundSniper was the only realized winner at +92 yen. Since it is basically a TradingView-to-MT5 execution bot, I read this result more as a check on the upstream signal and execution timing than as an AI judgment test. The open position was -118 yen at the report cutoff, though, so the clean-looking realized profit was already under pressure. That part made the +92 yen feel less safe than it looks.LLMBridgeTrader was the purest “AI decision” test of the day. It finished at -318 yen with only 1 win and 3 losses, and the open EURUSD position was also negative at -86 yen. Since this bot is allowed to decide not only direction but also OPEN, HOLD, CLOSE, and REVERSE, the weak point today looks like position handling after entry. The -243 yen largest loss is not huge by itself, but in a bot that is supposed to reason about closing, I want to see fewer losses left to reach that size.MLScore GF-T4 GB ended at -163 yen, but the structure was different from GateGrid AI. Its payoff ratio was 1.03, which is at least balanced: the average win and average loss were nearly the same size. The problem was hit rate, not reward size. The +303 yen take-profit near the end helped, and without it the day would have looked much uglier.Wrap-UpThe day ended negative, but not all negatives mean the same thing. GateGrid AI needs exit tightening because the win rate is already high but the loss size is not contained. LLMBridgeTrader needs better close-or-hold judgment because the AI layer is being asked to manage the whole plan, not just the entry. BoundSniper needs open-risk monitoring, and MLScore needs more selective entries.The uncomfortable part is that the headline number was not the total -789 yen. It was 80.0% win rate turning into a losing day. That is the kind of result that makes me trust the log more than the feeling. 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 headline from this week is uncomfortable, but useful: the bots were not simply bad at entries. Some of them were right more often than they were wrong, and that is exactly what made the result harder to ignore. Across the June 22–26 run, the total came in at -3,333 yen, and the number that bothered me most was not the loss itself. It was seeing a bot clear a 70% win rate and still fail to protect the account.This week pushed the experiment away from “Can the AI predict the next move?” and closer to “Can the system stop holding a broken idea?” That sounds like a small wording change, but in live MT5 operation it changes almost everything. Entry logic is visible and satisfying; exit discipline is less glamorous, and it is also where the damage was hiding.Bot-by-Bot Results■ GateGrid AIPeriod: June 22–26 weekly reviewRecord: 17W / 6L on June 24 reference day (Win rate 73.9%)Net P/L: Negative for the reviewed periodGross profit: Not fully disclosed in this logGross loss: Not fully disclosed in this logPayoff ratio: Weak, due to outsized lossesMax loss: Around -1,100 yen referenced■ MLScore GF-T4 GBPeriod: June 22–26 weekly reviewRecord: 1W / 1L on one reviewed day (Win rate 50.0%)Net P/L: Negative pressure on the weekly totalGross profit: +140 yen referencedGross loss: Around -600 yen referencedPayoff ratio: About 0.23 from the referenced pairMax loss: Around -600 yen referenced■ LLMBridgeTraderPeriod: June 22–26 weekly reviewRecord: 4W / 3L (Win rate 57.1%)Net P/L: Positive contributionGross profit: Not fully disclosed in this logGross loss: Not fully disclosed in this logPayoff ratio: 2.43Max loss: Not disclosed in this log■ TotalPeriod: June 22–26Record: Mixed across botsNet P/L: -3,333 yenGross profit: Not fully disclosed in this logGross loss: Not fully disclosed in this logPayoff ratio: Mixed, with LLMBridgeTrader offset by GateGrid AI and MLScore GF-T4 GBMax loss: Around -1,100 yen referencedToday’s Theme: The Trap Was Not Low AccuracyThe obvious story would be “the bots lost because the AI was wrong.” That is too simple, and honestly it does not match the logs. GateGrid AI, for example, produced a 17W / 6L day with a 73.9% win rate. When I saw that number next to a negative result, I had to pause for a second. A system that wins that often should not feel that fragile.The real issue was payoff structure. Small wins were being collected, then one large loss came in and erased the quiet work before it. A -700 yen or -1,100 yen stop on a grid-style bot is not just another losing trade; it is a design warning. The bot was not failing every minute. It was failing at the exact moment when the position idea had already been invalidated.GateGrid AI: The Grid Needed a Harder LineGateGrid AI is built around more than a simple grid. It uses CatBoost-style entry filtering, local LLM judgment through Ollama, ATR checks, session filters, spread monitoring, and adaptive grid management. On paper, that gives the bot several chances to avoid weak trades. In practice, the week showed that avoiding bad entries is not enough when a grid has already started stacking exposure.The painful part was the familiar one: many small wins, then one oversized loss. The bot could be “right” most of the time and still let one grid collapse dominate the week. I do not want to overstate certainty here, but the failure point looks more like the exit than the entry. The bot needed a rule that says, “This trade idea is no longer alive,” instead of letting the grid structure argue for more patience.The new rule is a forced exit after the second grid position is formed. If price breaks back through the first entry line and then continues a defined number of pips against the position, the system cuts. That condition matters because it is not random noise anymore. The second layer is already in, the first level has been violated, and the market has kept moving the wrong way. At that point, letting the position breathe may just be another word for postponing the loss.MLScore GF-T4 GB: Breakout Risk Had to Be FixedMLScore GF-T4 GB had a different problem. Even on a 1W / 1L sample, the structure was ugly: around +140 yen on the win and around -600 yen on the loss. That payoff ratio, roughly 0.23, is the sort of number that makes a 50% win rate almost irrelevant. I saw the +140 yen and -600 yen pairing and thought, not again — not because the trade lost, but because the ratio had already decided the result.The update here is simpler and more mechanical. For breakout setups, TP is now fixed at 30 pips and SL at 25 pips. Range logic stays unchanged, because the behavior of a range setup is different. But breakout trades should either accelerate or fail quickly, and the old structure allowed too much room for a failed breakout to become a large wound.By forcing the risk-reward to about 1.2, the bot is no longer allowed to take a breakout just because the score looks good. The AI or model can still identify the setup, but the system now refuses to let conviction stretch the stop too far. That is less romantic than letting the bot adapt freely, but live trading has a way of punishing freedom when it is not boxed in.LLMBridgeTrader: Lower Win Rate, Better Damage ControlLLMBridgeTrader was the useful counterexample. With 4W / 3L and a 57.1% win rate, it did not look like the cleanest bot by accuracy. Yet its payoff ratio was 2.43, and that changed the week’s interpretation. A lower win rate with better exits can beat a high win rate with oversized losses.This bot is closer to the experiment I actually want to run: not just asking the LLM for BUY, SELL, or NONE, but letting it reason about position actions such as OPEN, HOLD, CLOSE, and REVERSE. That added responsibility is risky, especially when the model can overreact or narrate confidence too well. Still, the week suggested that the exit side is where LLM judgment may be most interesting. The model does not need to be right all the time if it can stop being wrong quickly.I would not call this solved. REVERSE logic still needs caution, confidence thresholds need more testing, and the live-vs-backtest gap is always waiting in the background. But among the bots this week, LLMBridgeTrader showed the cleanest relationship between being wrong and paying a reasonable price for it.SummaryThe week ended at -3,333 yen, but the useful part was not the amount. The useful part was the pattern: high win rate did not save a weak exit design, and a modest win rate looked far healthier when the losses were contained.So the next phase is not more prediction for its own sake. GateGrid AI now has a forced retreat rule for grid breakdowns. MLScore GF-T4 GB has fixed breakout risk with TP 30 / SL 25. LLMBridgeTrader remains the experiment in whether an LLM can handle not only entries, but the harder question of when to stop believing its own plan.I still like AI-driven trading systems. I just trust them less when they are only good at starting trades. 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 strongest bot today was not the one with a 100% win rate. BoundSniper closed its single trade cleanly for +10 yen, which is fine, but the real driver was LLMBridgeTrader: 4 wins, 3 losses, +517 yen realized, and a payoff ratio of 2.43. I had to look twice at that combination because 57.1% does not sound dominant until the average win starts doing the work.The full realized result across the four bots was +524 yen. That number is not huge by itself, but the shape matters more than the size today. LLMBridgeTrader absorbed three losing trades, including a -194 yen hit that made me pause for a second, and still finished well ahead because its winners were allowed to breathe. That is exactly the kind of exit behavior I wanted to watch in this experiment.For the bot roles, I am treating BoundSniper as the TradingView execution bot, LLMBridgeTrader as the AI-led position planner, and GateGrid AI as the CatBoost plus Ollama gated grid system, based on the saved bot memo. ts■ GateGrid AI +71 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +89 yenGross loss: -18 yenPayoff ratio: 4.94Max loss: -18 yen■ BoundSniper +10 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +10 yenGross loss: 0 yenPayoff ratio: N/A, no losing tradeMax loss: 0 yen■ LLMBridgeTrader +517 yenRecord: 4W / 3LWin rate: 57.1%Gross profit: +748 yenGross loss: -231 yenPayoff ratio: 2.43Max loss: -194 yen■ MLScore GF-T4 GB -74 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +202 yenGross loss: -276 yenPayoff ratio: 0.73Max loss: -276 yen■ Total +524 yenRecord: 7W / 5LWin rate: 58.3%Gross profit: +1,049 yenGross loss: -525 yenPayoff ratio: 1.43Max loss: -276 yenOpen positions were still on the board at the report cutoff. LLMBridgeTrader had an unrealized +92 yen position, while MLScore GF-T4 GB had an unrealized -180 yen position. So the realized result was +524 yen, but the mark-to-market feel of the day was closer to +436 yen. I do not want to blur those two numbers, because open P/L can turn into a very different story by the next report.Today’s themeToday was an exit test more than an entry test. The entries mattered, of course, but the day was decided by what each bot did after being in the trade: whether it cut too early, held long enough, or let one loss dominate the session.That is especially important for the LLM-driven bots. When the model is allowed to decide not just direction but also OPEN, HOLD, CLOSE, or REVERSE, the question changes. I am no longer only asking, “Did it predict the next move?” I am asking whether it knew when to stop insisting on its first idea.GateGrid AIGateGrid AI only closed two positions today, one win and one small loss. The result was +71 yen with a 50.0% win rate, but the payoff ratio was 4.94 because the losing trade was only -18 yen. That -18 yen loss is the kind of small scratch I can live with; it does not force the next trade to become a rescue mission.The interesting part is that GateGrid AI did not need many trades to stay positive. This bot is built around filtering, with CatBoost first narrowing the entry probability and Ollama acting as a second gate. On a day like this, the low trade count is not automatically a weakness. It might simply mean the bot found only a couple of situations worth touching.The exit also looked controlled. There was no oversized loss hiding under a good win rate, and no open position left behind at the cutoff. I would not call this a strong day, but it was a clean one. For a grid-style bot, clean can be more valuable than exciting.BoundSniperBoundSniper had the cleanest record on paper: 1 win, 0 losses, +10 yen. A 100.0% win rate always looks nice for a second, then the amount pulls it back to earth. This bot did its job as an execution layer, and that is probably the correct way to read the result.Because BoundSniper is not trying to be an AI trader, I do not want to over-interpret the trade. It received the TradingView-side signal, entered, exited, and ended positive. No drama, no open exposure, no large adverse move.The limitation is that one trade tells us almost nothing about edge. It tells us the pipeline worked. That matters, especially in live automation, but the performance story belongs somewhere else today.LLMBridgeTraderLLMBridgeTrader was the center of the day. It closed 7 trades, won 4, lost 3, and still ended at +517 yen. The payoff ratio of 2.43 is the key number here. A 57.1% win rate with that payoff profile can survive a few mistakes, and today it did exactly that.The bot took three losses: -18 yen, -194 yen, and -19 yen. The -194 yen loss bothered me because it was large enough to test whether the rest of the session would become damage control. But the later winners, especially +369 yen, changed the whole texture of the result. That trade is where the bot stopped looking merely active and started looking useful.The open position also matters. At the cutoff, LLMBridgeTrader was holding a EURUSD sell position with +92 yen unrealized. That suggests the bot had not simply churned itself flat after the realized gain. It was still holding a live idea. Whether that was discipline or stubbornness will only be clear after the next close, but for today the exit logic looked better than I expected.MLScore GF-T4 GBMLScore GF-T4 GB was the weak spot. It had one win of +202 yen and one loss of -276 yen, leaving the realized result at -74 yen. The win rate was 50.0%, the same as GateGrid AI, but the payoff ratio was only 0.73. Same win rate, completely different feel.The maximum loss was -276 yen, which was also the largest closed loss across all bots. That is the kind of number that changes how I look at a flat-looking record. One win and one loss should be almost boring, yet here the loss carried more weight than the win.There was also an open GBPJPY buy position with -180 yen unrealized at the report cutoff. That does not mean the trade is wrong, but it does mean the day was not really finished for this bot. My suspicion is that the issue is not entry alone. The exit line, or maybe the distance between “hold” and “admit defeat,” needs more review.SummaryToday’s realized total was positive, but the real lesson came from the contrast between win rate and loss shape. BoundSniper had the perfect record and only added +10 yen. GateGrid AI won only half its trades and still stayed clean. LLMBridgeTrader carried the account because its average winner was large enough to cover its misses. MLScore GF-T4 GB reminded me that a 50.0% day can still feel heavy when the bigger side is the loss.I am not ready to call LLMBridgeTrader stable from one good session. But today, the AI-led exit decisions looked less like noise and more like something worth continuing to measure.② Substack NoteThe surprise from June 26 was simple: the 100% win-rate bot was not the star.BoundSniper went 1-for-1 and made +10 yen. Clean, but tiny.LLMBridgeTrader went only 4W / 3L, yet finished +517 yen because its winners were much larger than its losers. The payoff ratio came in at 2.43, and that changed the whole day.Total realized P/L across the four MT5 bots: +524 yen.The experiment is becoming less about “can the LLM pick direction?” and more about “can it stop holding the wrong idea, while staying long enough with the right 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

ConclusionThe day ended at -1,180 yen across four MT5 bots, and the uncomfortable part is that the record did not look broken at first glance. There were 9 winning exits and 7 losing exits overall, so the surface was not ugly. But the payoff ratio was only 0.26, and the largest single loss was -728 yen from GateGrid AI. I paused on that number for a moment, because it was bigger than the total gross profit of every bot combined.The main theme today is exit quality. For the bots that hand judgment to an LLM or an AI layer, the question is no longer just “was the entry right?” It is whether the model knows when the original idea has expired. Today, that part still feels unfinished.Bot-by-bot results■ GateGrid AI -512 yenRecord: 5W / 2LWin rate: 71.4%Gross profit: +235 yenGross loss: -747 yenPayoff ratio: 0.13Max loss: -728 yen■ BoundSniper -25 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +52 yenGross loss: -77 yenPayoff ratio: 0.34Max loss: -77 yen■ LLMBridgeTrader -175 yenRecord: 1W / 3LWin rate: 25.0%Gross profit: +162 yenGross loss: -337 yenPayoff ratio: 1.44Max loss: -201 yen■ MLScore GF-T4 GB -468 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +144 yenGross loss: -612 yenPayoff ratio: 0.24Max loss: -612 yen■ Total -1,180 yenRecord: 9W / 7LWin rate: 56.3%Gross profit: +593 yenGross loss: -1,773 yenPayoff ratio: 0.26Max loss: -728 yenToday’s themeThe strange thing about this run is that the losing day was not caused by constant bad entries. GateGrid AI won most of its exits. BoundSniper also had more winning closes than losing ones. Even MLScore was split one and one. And still, the day sank because the losing trades were far larger than the winning trades.That makes this less of a signal problem and more of an exit problem. The bots can find small profitable windows, but when price moves against them, the stop behavior and close timing are still too heavy. A 71.4% record with a 0.13 payoff ratio is not strength; it is a warning label written in small numbers.GateGrid AIGateGrid AI was the most painful bot to read today. It finished with 5 wins and 2 losses, which sounds fine until the -728 yen loss appears at the end. The five wins added only +235 yen, so one late loss erased all of them and then some. Seeing -728 yen after a string of small wins had that familiar “not this shape again” feeling.The entry filter may still be doing something useful. GateGrid AI did not spray random losing trades all day. The problem is that the grid logic and exit logic allowed one position to become too large relative to the normal win size. If the bot is designed to collect small moves, then a single loss cannot be allowed to equal fifteen small wins. That is where the current structure looks fragile.For an ML plus LLM hybrid bot, the next review should focus on the moment it stops believing in the setup. CatBoost and Ollama may help filter entries, but once a position is live, the bot also needs a stronger “the idea is no longer valid” trigger. I suspect the issue is not the first decision. It is the delay in giving up.BoundSniperBoundSniper ended at -25 yen, and this one is a different kind of result. The trade logic itself is not AI-driven; it passes TradingView signals into MT5. So I do not read this as a model judgment failure. It is more about execution, signal timing, and the cost carried by the position.The first close showed +28 yen on price movement, but after swap it became a net drag. That is small, but it matters because the other wins were only +10 yen and +42 yen. A tiny edge disappears quickly when the holding cost is not small relative to the expected win.BoundSniper did not collapse today. Still, its payoff ratio was only 0.34 on a net basis. That means it needs either cleaner exits or larger average wins, because a bot that depends on TradingView rules cannot count on AI interpretation to rescue weak trade economics later.LLMBridgeTraderLLMBridgeTrader is the most interesting bot today, even though the result was negative. It only won once and lost three times, but its payoff ratio was 1.44. That means the structure is not hopeless. One winning exit was large enough to cover more than one average loss, at least in theory.The issue is frequency and sequence. After the +162 yen win, the bot took -57 yen, then -201 yen, then -79 yen. The model is allowed to decide OPEN, HOLD, CLOSE, and REVERSE, so the exit decision is part of the experiment, not just a mechanical afterthought. Today, the AI did close trades, but it did not avoid the cluster of small-to-medium losses that followed.This is where LLM trading gets uncomfortable. The model can describe a reason, and the log can preserve that reason, but the account only cares whether the reason led to a better exit. I would not throw away this setup from one day. I would look harder at confidence thresholds for CLOSE and REVERSE, because the bot may need to be more conservative once it has already taken a directional loss.MLScore GF-T4 GBMLScore GF-T4 GB had only two closed results, so I do not want to overstate the sample. Still, the shape was clear: one net win of +144 yen after swap, then one loss of -612 yen. That gave it a 50.0% record but a payoff ratio of only 0.24. Half right is not enough when the wrong side is four times heavier.The -612 yen loss is the second biggest single loss of the day. It did not come from a long sequence of mistakes; it came from one trade that carried too much damage. That makes the review simple, though not easy. The bot needs a better hard stop, or it needs to size down when the expected stop distance is wide.This bot may still be useful as a scoring layer, but today it behaved like a model that can be directionally right sometimes while still failing the risk shape. I do not have enough from one day to say the score is bad. The exit width is the part I would question first.SummaryToday was not a clean “AI failed” day. It was more specific than that. The bots found winners, and some of the entry logic looked alive, but the loss distribution was badly tilted. Total gross profit was +593 yen against -1,773 yen in gross losses, and that gap tells the story more honestly than the win count.For the next tuning pass, I would not start by chasing more entries. I would start with maximum loss rules, earlier invalidation, and stricter handling of HOLD turning into CLOSE. The experiment is still worth running, but today the market reminded me that a smart entry is only half a trade 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 total result was positive: +455 yen across 16 closed trades. That sounds clean enough, and honestly, seeing the total stay above zero was a relief. But the win rate is almost the least interesting number today. The whole portfolio went 13W / 3L, yet the total payoff ratio was only 0.54, meaning the average losing trade was still larger than the average winning trade.The main issue was not entry accuracy. It was loss shape. GBPUSD, which I track as GateGrid AI based on the bot setup notes, won 5 out of 7 trades and still finished at -132 yen. That number made me pause a little, because this is the exact kind of day where a “good win rate” can hide a weak exit structure. The bot notes describe GateGrid AI as a CatBoost + Ollama multi-gate system, with logs such as AI_SKIP(sess=NY gate=0.50 base_thr=0.54 adj_thr=0.55) and OLLAMA_HOLD, so the design is already focused on filtering bad entries. Today’s P/L suggests the next place to inspect is after entry: when to stop holding, when to cut, and whether the grid loss is allowed to grow too far.Bot Results■ GBPJPY Bot +200 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +200 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ LLMBridgeTrader +167 yenRecord: 3W / 1LWin rate: 75.0%Gross profit: +173 yenGross loss: -6 yenPayoff ratio: 9.61Max loss: -6 yen■ BoundSniper Bot +220 yenRecord: 4W / 0LWin rate: 100.0%Gross profit: +220 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ GateGrid AI -132 yenRecord: 5W / 2LWin rate: 71.4%Gross profit: +207 yenGross loss: -339 yenPayoff ratio: 0.24Max loss: -205 yen■ Total +455 yenRecord: 13W / 3LWin rate: 81.3%Gross profit: +800 yenGross loss: -345 yenPayoff ratio: 0.54Max loss: -205 yenToday’s Theme: Loss Size Beat Win RateThe cleanest bot on paper was BoundSniper Bot on USDJPY. Four trades, four wins, +220 yen. No losing trade means I cannot evaluate the payoff ratio yet, but as a pure execution bot that follows TradingView-side signals, this was a very good session.LLMBridgeTrader on EURUSD was the strongest from a risk-shape view. It took one tiny loss of -6 yen and then built +167 yen total. A payoff ratio of 9.61 is almost too clean for one day, so I would not overtrust it yet, but the exit behavior looked good. It did not let the bad trade become a story.GBPJPY Bot had one trade and closed +200 yen. That result helps the day, but one trade is too thin to judge. Still, one clean winner with no damage is not something I complain about.GateGrid AI is where the day gets interesting. Five wins created only +207 yen, while two losses took -339 yen. The average win was 41.4 yen, while the average loss was 169.5 yen. That means this bot needs roughly an 80% win rate just to break even under today’s loss shape. A 71.4% win rate sounds good until the math quietly turns against it.Bot-by-Bot ReadBoundSniper Bot did what a rule-following execution bot is supposed to do: it captured small USDJPY moves without taking damage. Since this bot itself does not make the market prediction, the key review point is not “AI judgment,” but signal quality and execution slippage. Today, nothing in the result suggests an execution problem.LLMBridgeTrader had the best balance. A -6 yen loss is the kind of loss I like to see from an AI-led bot because it means the system was willing to abandon the idea quickly. The +129 yen EURUSD short was the main contributor, and the later +36 yen and +8 yen trades added without giving much back.GateGrid AI needs the most review. The entry filter may still be useful, but the exit side looks loose. I cannot say the AI made a bad judgment without the matching daily log, but the numbers point in that direction: once the position was allowed, the losing side stayed open long enough to erase five smaller wins. The -205 yen loss was the trade that stopped me.Wrap-UpToday ended positive, but not because every bot was healthy. The portfolio survived because USDJPY, GBPJPY, and EURUSD covered the GBPUSD damage. For the next review, I would not start by improving win rate. I would start with GateGrid AI’s maximum loss, trailing behavior, and the exact moment it chose not to exit.A profitable day can still leave homework. 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

Today was not a day I want to judge by win count. The four-Bot portfolio closed at -2,457 yen, and the reason was not that every system failed at entries. It was simpler and more uncomfortable: the losing trades were too heavy compared with the winners.The cleanest Bot on the sheet was LLMBridgeTrader, which finished at +353 yen with a payoff ratio of 5.24. That number stopped me for a second, because it was the only Bot that looked like it knew how to be wrong cheaply. GateGrid AI, on the other hand, had many small profitable exits but ended at -1,482 yen because one loss, -733 yen, swallowed too much of the day.The cumulative result is therefore -2,457 yen, from a combined starting balance of 168,415 yen to 165,958 yen across the four accounts.Bot-by-bot results■ GateGrid AI -1,482 yenPair: GBPUSDClosed trades: 14Record: 10W / 4LWin rate: 71.4%Gross profit: +519 yenGross loss: -2,001 yenPayoff ratio: 0.10Max loss: -733 yen■ MLScore GF-T4 GB -244 yenPair: GBPJPYClosed trades: 1Record: 0W / 1LWin rate: 0.0%Gross profit: 0 yenGross loss: -244 yenPayoff ratio: N/AMax loss: -244 yen■ LLMBridgeTrader +353 yenPair: EURUSDClosed trades: 4Record: 3W / 1LWin rate: 75.0%Gross profit: +377 yenGross loss: -24 yenPayoff ratio: 5.24Max loss: -24 yen■ BoundSniper Bot -1,084 yenPair: USDJPYClosed trades: 6Record: 3W / 3LWin rate: 50.0%Gross profit: +216 yenGross loss: -1,300 yenPayoff ratio: 0.17Max loss: -468 yen■ Total -2,457 yenClosed trades: 25Record: 16W / 9LWin rate: 64.0%Gross profit: +1,112 yenGross loss: -3,569 yenPayoff ratio: 0.18Max loss: -733 yenToday’s theme: the exit mattered more than the entryThe main story is not “which Bot had more winning trades.” It is how much damage each Bot allowed when the trade was wrong. Across the portfolio, the average winning trade was about 69.5 yen, while the average losing trade was about 396.6 yen. That gap is too wide. It means one loss needed almost six average wins just to repair it.This is where LLMBridgeTrader stood out. Its one losing trade was only -24 yen, and the three winners were large enough to cover it without drama. I do not want to overpraise one day of data, but this is the shape I want from an AI-driven trading Bot: not perfect prediction, just fast retreat when the premise weakens.The MT5 report did not include the full AI decision logs for this day. I only had execution comments such as “LLMBridgeTrader_”, “[sl 1.14622]”, “[sl 213.719]”, and “BoundSniper OPEN”. That matters, because the most useful analysis would connect the Bot’s actual reasoning to the exit result, not just the final yen amount.GateGrid AI: many small exits, one large woundGateGrid AI is supposed to filter entries with a multi-stage design: model gate, Ollama-style judgment, volatility checks, session control, and grid management. On paper, that should protect it from bad conditions. Today’s results still show a familiar grid problem: the winners were small, and the losses had room to grow.The gross profit was +519 yen, but gross loss reached -2,001 yen. The payoff ratio was 0.10, which is the uncomfortable part. A small winner like +8 yen or +19 yen feels harmless while it is happening, but it does not build enough cushion when a -733 yen exit appears later. Seeing that -733 yen line made me pause, because this was not just a losing trade; it was a statement about the exit width.The issue is probably not entry frequency alone. The question is whether the Bot should cut the grid earlier when price keeps moving against the cluster. I still need the actual AI_SKIP / OLLAMA_HOLD / close-reason logs to say that with confidence, but the PnL shape points toward exit control.MLScore GF-T4 GB: one trade, no room to judgeMLScore GF-T4 GB had only one closed trade on GBPJPY and finished at -244 yen. The MT5 comment shows “[sl 213.719]”, so this was a stop-based exit rather than an active recovery sequence.There is not enough here to judge the model. One trade can be noise. Still, for a portfolio day, a single stop loss matters when the rest of the Bots are already carrying wide downside. I would treat this Bot as “not guilty yet,” but not invisible either.LLMBridgeTrader: the best result came from losing smallLLMBridgeTrader was the one clean positive result: +353 yen, with only -24 yen of gross loss. That is the part I care about more than the win count. It did not need many trades to recover; the negative trade was simply small enough.The MT5 report shows two profitable exits marked with stop-style comments, including “[sl 1.14622]” and “[sl 1.14192]”. That looks like a protective stop or locked-in exit behavior rather than a raw fixed loss. If that reading is right, then the Bot’s exit design did more work than the entry direction.This is the sort of behavior I want to keep watching. LLMBridgeTrader is the Bot where the AI is meant to decide not only BUY / SELL, but also OPEN / HOLD / CLOSE / REVERSE. Today, I cannot see the actual reasoning text, but the result suggests that the exit side deserves more credit than the entry side.BoundSniper Bot: the executor did its job, the loss size did notBoundSniper Bot finished at -1,084 yen on USDJPY. This Bot is not trying to predict the market by itself. It receives TradingView signals through the webhook route and sends the corresponding orders to MT5, so the real evaluation belongs upstream: signal quality, stop size, and whether the exit logic is too late.The shape was rough. Gross profit was only +216 yen, while gross loss reached -1,300 yen. The largest loss was -468 yen, and there were three losses in that same heavy zone: -420, -412, and -468. It is hard not to see that as a structural issue rather than a bad tick.BoundSniper may be doing exactly what it was told to do. That does not make the strategy healthy. For this Bot, I would not start by changing the MT5 bridge; I would first review the TradingView exit condition and the distance between “wrong” and “closed.”SummaryThe portfolio did not lose because every Bot was directionally bad. It lost because the negative trades were allowed to become too large compared with the average positive trade. LLMBridgeTrader was the exception, and that is why it is the main reference point for the next review.For the next run, I want to see the actual AI decision logs beside the trades. The yen result tells me what happened; the logs would tell me whether the Bot hesitated, protected, reversed, or simply waited too long.Editing note to myself: next time, paste the AI reasoning logs too, especially OPEN / HOLD / CLOSE / REVERSE reasons, confidence, setup type, and close reason. 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

Win Rate Lied This Week: The Rule-Based Bot Survived While the LLM Bots BledMT5 LLM auto-trading report, June 15–19, 2026.This is Day 5 of the running log. The four-bot portfolio finished the window at -3,490 yen cumulative, even though several days showed decent-looking win rates on the surface.The uncomfortable part is not the loss itself. It is the shape of the loss. GateGrid AI kept showing high win-rate behavior, yet one large basket loss could erase a pile of small wins. BoundSniper, the least “AI-like” bot in the group, quietly ended as the only steady positive contributor. That made me pause a bit; it is not the result I wanted from an LLM-heavy experiment, but it is the result on the screen.The five-day total moved like this: +282 yen, -1,445 yen, -1,615 yen, -464 yen, -248 yen. Seeing a 53.3% win-rate day end at -1,445 yen still feels wrong at first glance. Then the payoff ratio explains it. The system was winning often enough, but not winning large enough.Bot-by-bot resultsTrade-level counts were not fully included in the provided block, so I treated each date’s final Bot result as one result unit. Where specific trade-level clues were given, I mention them in the analysis rather than pretending the missing rows are available.■ GateGrid AI -1,367 yenRecord: 2 positive days / 3 negative daysDay-level win rate: 40.0%Gross profit: +203 yenGross loss: -1,570 yenPayoff ratio: 0.19Max reported daily loss: -712 yen■ BoundSniper +271 yenRecord: 4 positive days / 1 negative dayDay-level win rate: 80.0%Gross profit: +303 yenGross loss: -32 yenPayoff ratio: 2.37Max reported daily loss: -32 yen■ LLMBridgeTrader -816 yenRecord: 1 positive day / 4 negative daysDay-level win rate: 20.0%Gross profit: +33 yenGross loss: -849 yenPayoff ratio: 0.16Max reported daily loss: -466 yen■ MLScore GF-T4 -1,578 yenRecord: 0 positive days / 4 negative days / 1 flat dayDay-level win rate: 0.0%Gross profit: +0 yenGross loss: -1,578 yenPayoff ratio: N/AMax reported single-trade loss: -602 yen■ Total -3,490 yenRecord: 7 positive bot-days / 12 negative bot-days / 1 flat bot-dayDay-level win rate: 36.8% excluding flat resultGross profit: +539 yenGross loss: -4,029 yenPayoff ratio: 0.23Max reported daily loss: -712 yenToday’s theme: exits beat win rateThe main theme this time is not portfolio diversification. It is exit quality. A bot can filter entries, avoid bad setups, and still lose if the exit logic lets one bad position grow beyond the size of many normal wins.GateGrid AI is the clearest example. Its design is built around not entering weak conditions: CatBoost checks the gate first, then Ollama can return defensive decisions such as AI_SKIP(sess=NY gate=0.50 base_thr=0.54 adj_thr=0.55) or OLLAMA_HOLD. That kind of log is useful because it tells me the machine is not blindly firing orders. But the five-day result says the harder problem sits after the entry: once a position or basket survives the filters, the loss needs to be cut before it becomes the whole story. Bot design notes describe GateGrid AI as a CatBoost + Ollama multi-gate system, while BoundSniper mainly relays TradingView signals to MT5 and LLMBridgeTrader asks AI to output OPEN/HOLD/CLOSE/REVERSE style position actions.GateGrid AIGateGrid AI ended at -1,367 yen. The raw daily path was +67, -703, -712, -155, +136 yen. The last day recovered a little, but the middle of the week had already done the damage.The frustrating part is that the bot is not reckless by design. It is supposed to block weak entries with CatBoost and then ask Ollama to judge the environment with spread, ATR, higher-timeframe trend, session, recent win rate, and recent P/L. That is a good structure on paper. Still, the result looked like a classic small-win, large-loss pattern. The entry gate may be doing something useful, but the basket exit is probably still too forgiving. I do not have full certainty yet, but that is where my eyes go first.A payoff ratio of 0.19 on the day-level summary is a warning sign. I know this is not the exact trade-level payoff ratio, but the shape is hard to ignore. If the average losing day is five times the average winning day, a high internal win rate becomes less comforting very quickly.BoundSniperBoundSniper finished at +271 yen, and it did it with the least dramatic architecture. This bot is basically an execution bridge for TradingView signals on USDJPY. It does not try to be clever about the market itself.That simplicity helped. The daily path was +182, +3, -32, +20, +98 yen. No huge win, no heroic AI judgment, no long explanation needed. The largest negative day was only -32 yen, which almost feels boring, but boring was valuable this week.The payoff ratio came out at 2.37 on a day-result basis. That is the only bot where the loss side did not dominate the week. I would not overpraise it from five days of data, but in this window it behaved like the adult in the room.LLMBridgeTraderLLMBridgeTrader ended at -816 yen. The daily line was +33, around -261, -466, -92, -30 yen. Not pretty, but the loss profile is different from GateGrid AI.This bot matters because it asks AI to manage more than direction. It can choose OPEN, HOLD, CLOSE, REVERSE, or NONE, and it also produces confidence, setup type, SL pips, TP pips, entry reason, and exit reason. In theory, that gives it a better chance to escape bad positions by switching from holding to closing. In this five-day block, the result still landed negative, but the last two days were relatively contained at -92 and -30 yen. That does not prove the exit logic works, though it hints that the damage may be more controlled than the headline win rate suggests.I would keep watching the CLOSE and REVERSE decisions. If this bot is going to become useful, the edge will probably come less from calling direction perfectly and more from admitting the trade is no longer worth holding.MLScore GF-T4MLScore GF-T4 was the heaviest drag after GateGrid AI, finishing at -1,578 yen. The reported path was 0, -487, -405, about -234, and -452 yen. There was no positive day in the period.The entry-blocking function seems to be doing part of its job, but the trades that do get through carry too much downside. The note that June 19 had one losing trade around -602 yen is the kind of number that changes the feel of the whole bot. I saw that and thought, not again with the wide stop.This bot may not need more intelligence first. It may need a smaller permission space. Fewer trades are not enough if the approved trades can still hit a loss size that the rest of the portfolio cannot absorb.SummaryThe week ended negative, but the useful finding is clear: the best-looking AI structure did not automatically create the best risk structure. GateGrid AI had smart filters and still lost badly. LLMBridgeTrader had richer decision language and still could not climb out. MLScore GF-T4 blocked some entries but let too much loss through when it acted.BoundSniper, the simple rule-based execution bot, was the only one that left the week positive. I do not think that means “AI failed” in some grand way. It means the experiment has moved from entry quality to exit discipline. The next improvement should probably be less about asking the model to be smarter, and more about making it harder for any one trade or basket to become the whole week. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe

A 72.2% win rate should have made this a decent trading day. It did not. Across four MT5 bots, the combined record was 13 wins and 5 losses, but the final result was -248 yen.For this log, I am treating June 19, 2026 as Day 1 of the published series. Cumulative P/L is now -248 yen. The important part was not that the bots failed to find winners. They found plenty. The problem was that the average loss was too large compared with the average win.Bot results■ GateGrid AI +136 yenSymbol: GBPUSD-Record: 7W / 1LWin rate: 87.5%Gross profit: +296 yenGross loss: -160 yenPayoff ratio: 0.26Max loss: -160 yen■ BoundSniper +98 yenSymbol: USDJPY-Record: 3W / 0LWin rate: 100.0%Gross profit: +98 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ LLMBridgeTrader -30 yenSymbol: EURUSD-Record: 2W / 3LWin rate: 40.0%Gross profit: +254 yenGross loss: -284 yenPayoff ratio: 1.34Max loss: -132 yen■ MLScore GF-T4 GBPJPY -452 yenSymbol: GBPJPY-Record: 1W / 1LWin rate: 50.0%Gross profit: +150 yenGross loss: -602 yenPayoff ratio: 0.25Max loss: -602 yen■ Total -248 yenRecord: 13W / 5LWin rate: 72.2%Gross profit: +798 yenGross loss: -1,046 yenPayoff ratio: 0.29Max loss: -602 yenRunning day: Day 1Cumulative P/L: -248 yenToday’s theme: the win rate looked fine, the payoff ratio did notThe headline number was 72.2%. On paper, that sounds like a day where the bots were mostly right. But the average winning trade was about 61 yen, while the average losing trade was about 209 yen. That is the part that explains the result.The bots did not need many losing trades to finish negative. One -602 yen loss from MLScore GF-T4 GBPJPY was enough to offset a large part of the smaller wins from the other systems. This was a day where the hit rate gave a comfortable impression, but the payoff structure told a different story.GateGrid AI: profitable, but still dependent on small wins holding upGateGrid AI finished at +136 yen, the best net result among the four bots. The record was 7 wins and 1 loss, with an 87.5% win rate. That looks strong, but the payoff ratio was only 0.26, so the wins were frequent and small.The AI layer was active. One log line showed the system allowing a BUY grid with sig=BUY, conf=0.75, timing=TREND_FOLLOW, and a reason beginning with “ML DEFENSIVE.” That tells me the bot was not simply stacking orders without a filter. It was passing through a mix of ML scoring and LLM judgment.The exit side still needs attention. The log repeatedly showed: “price hit but pnl=-348.00 BoundSniper: simple execution, clean resultBoundSniper finished at +98 yen with 3 wins and no losses. This bot is not trying to interpret the market through an LLM. Its job is to receive TradingView signals through a webhook and execute them on MT5.The live monitor showed the webhook server, cloudflared tunnel, and MT5 trader all running, with public health marked OK. That is not a dramatic trading insight, but it matters. A signal relay bot first has to be reliable as infrastructure.The profit was small, but the result was clean. BoundSniper did not add unnecessary complexity to the day. It received signals, executed them, and closed positive.LLMBridgeTrader: lower win rate, better loss shapeLLMBridgeTrader finished at -30 yen. The win rate was only 40.0%, with 2 wins and 3 losses, but the payoff ratio was 1.34. That makes this bot more interesting than the final P/L suggests.The AI log included the exit reason: “Close managed position as strong downtrend invalidates reversal setup.” This is the part worth following over time. The bot is not only choosing entries; it is also explaining when the original trade idea no longer holds.There were also mean-reversion BUY ideas inside a strong bearish environment. One log phrase was: “Oversold RSI 16 in strong bear trend indicates potential pullback.” That logic is understandable, but it can be fragile. Oversold conditions inside a trend do not always mean reversal. Still, the largest loss was -132 yen, so the damage was contained compared with the GBPJPY bot.MLScore GF-T4 GBPJPY: the one trade that changed the portfolioMLScore GF-T4 GBPJPY was the main drag on the day. It had only two closed trades, one win and one loss. The win was +150 yen, while the loss was -602 yen. That left the bot at -452 yen.The score log showed candidate=SELL decision=ENTER signal=SELL score=93.5 trade=done. The score was high, the trade was accepted, and the system entered. The result later became the largest loss of the day.This does not mean the score model is broken. A high-score setup can still lose. The issue is that the loss size was too large relative to the win size. For GBPJPY, the next review should probably focus less on signal confidence and more on stop size, volatility adjustment, and daily loss limits.SummaryDay 1 ended at -248 yen. Two bots finished positive, one was only slightly negative, and one large GBPJPY loss pulled the total below zero. The portfolio did not lose because it could not win trades. It lost because the losing trades were too heavy.The result is a useful starting point for the series. Entry accuracy is visible and easy to talk about, but the exit design is where the real test begins. 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 result for June 18 was simple, but a little uncomfortable: four MT5 auto-trading bots closed the day at -464 yen. The portfolio won 27 out of 36 trades, so the surface number looked fine. Still, the payoff ratio was only 0.27, and that is where the day fell apart.This was not a day where the bots failed to find entries. They found plenty. The real question was whether they knew when to stop believing those entries. I think the problem sits mostly at the exit, though the evidence is not perfectly clean yet.Bot-by-bot results■ GateGrid AI -155 yenSymbol: GBPUSD-Closed trades: 21Record: 17W / 4LWin rate: 81.0%Gross profit: +955 yenGross loss: -1,110 yenPayoff ratio: 0.20Max loss: -443 yen■ BoundSniper Bot +20 yenSymbol: USDJPY-Closed trades: 7Record: 6W / 1LWin rate: 85.7%Gross profit: +446 yenGross loss: -426 yenPayoff ratio: 0.17Max loss: -426 yen■ LLMBridgeTrader -92 yenSymbol: EURUSD-Closed trades: 5Record: 3W / 2LWin rate: 60.0%Gross profit: +348 yenGross loss: -440 yenPayoff ratio: 0.53Max loss: -241 yen■ MLScore GF-T4 GB -237 yenSymbol: GBPJPY-Closed trades: 3Record: 1W / 2LWin rate: 33.3%Gross profit: +265 yenGross loss: -502 yenPayoff ratio: 1.06Max loss: -252 yen■ Total -464 yenClosed trades: 36Record: 27W / 9LWin rate: 75.0%Gross profit: +2,014 yenGross loss: -2,478 yenPayoff ratio: 0.27Max loss: -443 yenSeries day: Day 1 in this provided logCumulative P&L: -464 yenToday’s theme: entry confidence did not protect the downsideThe most interesting contrast was not between winners and losers. It was between win rate and damage size. GateGrid AI won more than 80% of its exits, but still ended negative. BoundSniper Bot won almost everything and barely escaped positive. Seeing a -443 yen single loss inside GateGrid made me pause, because the rest of the day was mostly small repairs.The ML score bot was even more direct. The GBPJPY engine printed candidate=SELL decision=ENTER signal=SELL score=95.09 trade=done, but that first SELL later closed at -252 yen. A score over 95 feels strong on screen. In the account report, it was just the first of two stop losses before the final win.GateGrid AIGateGrid AI’s final number was -155 yen, but that result hides a rough start. The first two closed trades were -379 yen and -443 yen, and the log says it plainly: [CAP] Basket max-loss exit: pnl=-822.00 The win rate was 81.0%, which sounds good until the payoff ratio shows up at 0.20. Average winners were small; average losers were too heavy. This is the kind of day where the grid logic can look active and controlled, while the account curve is still paying for one bad pocket of exposure.BoundSniper BotBoundSniper Bot was the only bot to finish positive, but only by +20 yen. That number is almost funny after a 6W / 1L record. I had to look twice, because a win rate of 85.7% usually feels like it should leave more behind.The explanation is blunt: six wins made +446 yen, and one loss took back -426 yen. Payoff ratio was 0.17. BoundSniper is not using the same kind of LLM planning as LLMBridgeTrader, so I do not want to force the “AI exit” story onto it. But as a trading system, it is showing the same design issue: one bad exit can consume a clean run of small closes.LLMBridgeTraderLLMBridgeTrader lost -92 yen, but it gave the most useful AI log of the day. Near the final EURUSD trade, the model opened a BUY with a mean-reversion setup: RSI oversold bounce in weak ranging market. Then, fifteen minutes later, it chose to close with position_action":"CLOSE" and the exit reason Weak ADX and bearish structure favor closing. That close finished as a +90 yen trade.This is the part I like. The bot was not only saying BUY or SELL. It was also changing its mind about holding the position. The full day was still negative because the earlier two losses were larger than the later wins, but the exit behavior itself was not random. It saw weak trend conditions and got out. That is closer to the experiment I want this bot to run.MLScore GF-T4 GBMLScore GF-T4 GB had the lowest win rate at 33.3%, yet its payoff ratio was the best of the group at 1.06. That sounds contradictory, but it fits the trades: two losses around -250 yen, then one win at +265 yen. The structure was not terrible. The timing was.The entries were all SELL signals with strong scores, including 95.09, 92.89, and 93.5. The issue is that high score did not mean high follow-through. If this bot keeps using score as the main gate, the next layer probably has to judge when a high-score setup is already late.Wrap-upThe day ended at -464 yen. Not a disaster, but not a clean loss either. The strange part is that the portfolio was right often enough. It just did not get paid enough when right, and it paid too much when wrong.For this series, today’s lesson is not “raise the win rate.” The bots already did that. The better question is whether each bot can recognize the moment when its original idea has expired. That is where the next improvement probably lives. 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

ConclusionJune 17 was not a “win rate day.” The four MT5 bots ended at -1,615 yen, and the strange part is that the bot with a 33.3% win rate, LLMBridgeTrader, lost less than GateGrid AI at 50.0%. I had to look twice at that. The answer was not hidden in the entry count. It was in payoff ratio and the size of the worst exits.For this pasted record, I am treating it as Day 1 / cumulative -1,615 yen, because no earlier running total was included. The combined final balance across the four MT5 accounts was 169,127 yen after the day’s trades.Bot Results■ GateGrid AI -712 yenPair: GBPUSD-Record: 2W / 2LWin rate: 50.0%Gross profit: +84 yenGross loss: -796 yenPayoff ratio: 0.11Max loss: -431 yen■ BoundSniper Bot -32 yenPair: USDJPY-Record: 2W / 2LWin rate: 50.0%Gross profit: +64 yenGross loss: -96 yenPayoff ratio: 0.67Max loss: -88 yen■ LLMBridgeTrader -466 yenPair: EURUSD-Record: 3W / 6LWin rate: 33.3%Gross profit: +713 yenGross loss: -1,179 yenPayoff ratio: 1.21Max loss: -245 yen■ MLScore GF-T4 GB -405 yenPair: GBPJPY-Record: 1W / 2LWin rate: 33.3%Gross profit: +205 yenGross loss: -610 yenPayoff ratio: 0.67Max loss: -353 yen■ Total -1,615 yenPairs: GBPUSD- / USDJPY- / EURUSD- / GBPJPY-Record: 8W / 12LWin rate: 40.0%Gross profit: +1,066 yenGross loss: -2,681 yenPayoff ratio: 0.60Max loss: -431 yenToday’s Theme: Win Rate Did Not Protect the AccountGateGrid AI and BoundSniper both ended with a 50% win rate. That sounds acceptable at first glance. But GateGrid’s average win was only 42 yen, while its average loss was 398 yen. Seeing -431 yen as the largest single loss made the whole day feel different. This was not a small miss. It was a payoff structure problem.LLMBridgeTrader looked worse by win rate. It only won 3 out of 9 exits. But its payoff ratio was 1.21, the only bot above 1.0 today. That did not save the day, but it kept the damage from becoming the worst result on the board. The exits were still noisy, and I do not want to overpraise a losing bot. Still, the shape was healthier than the headline win rate suggested.Bot-by-Bot AnalysisGateGrid AIGateGrid AI had the cleanest warning sign of the day. Two winners, two losers, and still -712 yen. The winners were +74 yen and +10 yen. The losers were -365 yen and -431 yen. When the wins are that small, even a decent entry filter cannot carry the system.This bot is designed to filter entries through CatBoost and Ollama. The design notes include logs like AI_SKIP(sess=NY gate=0.50 base_thr=0.54 adj_thr=0.55) and OLLAMA_HOLD, which show that the bot is supposed to avoid bad setups instead of always trading. Today’s report does not include the full live reasoning trace behind the two GBPUSD exits, and that missing context matters. Without the actual decision text, I can only say this much: the entry side may have passed the filters, but the exit side let the losing grid grow too large compared with the take-profit size.BoundSniper BotBoundSniper was almost flat, but not in the clean way. The price-side closing profit totaled +102 yen, yet swap of -134 yen pulled the final result down to -32 yen. That little reversal is easy to ignore, but it is the kind of cost that slowly changes the personality of a strategy.This bot is not making AI decisions. It receives TradingView signals and sends them to MT5. The comments were simple execution markers such as BoundSniper OPEN and BoundSniper clos. That simplicity is useful because there is less ambiguity. If the day goes wrong here, the question is usually not “what did the LLM think?” but whether the TradingView rule and holding time still make sense after costs.LLMBridgeTraderLLMBridgeTrader is the most interesting loser today. The record was bad on the surface: 3 wins and 6 losses. But the biggest loss was -245 yen, while the biggest win was +399 yen. That is why it lost less than GateGrid despite a lower win rate. I did not expect the “uglier” win rate to produce the more controlled loss.The execution comments show multiple exits labeled like [sl 1.15813], [tp 1.15665], and [sl 1.14949]. One confusing part is that some [sl] exits were profitable, such as +157 yen. That probably reflects stop adjustment or the way MT5 comments preserve the order label, not a simple “SL equals loss” story. For an LLM-driven bot, this is exactly where the next layer of logs is needed: why did the AI keep holding, close, or allow the stop to sit where it did?MLScore GF-T4 GBMLScore GF-T4 GB finished at -405 yen with 1 win and 2 losses. The first close had swap -78 yen and price loss -275 yen, so the net damage of that one exit was -353 yen. That one stung more than the trade count suggests.The middle trade did work, closing at +205 yen, but the second loss at -257 yen erased it and then some. The structure looked similar to BoundSniper in payoff ratio, but with a larger max loss. It needs either a better loss cap or a reason to avoid the second entry after the first session had already absorbed damage.SummaryThe day was negative, but it was not evenly negative. GateGrid AI looked reasonable by win rate and weak by payoff. LLMBridgeTrader looked weak by win rate and more defensible by loss shape. That is the uncomfortable part of running these bots side by side: the number that feels easiest to understand is not always the number that tells the truth.Editor’s note to myself: next time, paste the full AI decision logs with confidence, setup type, OPEN/HOLD/CLOSE/REVERSE reason, and exit reason. 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

June 16, 2026 was not a “bad entries” day as much as an “exit discipline” day. Across the four MT5 bots, the combined realized result was -1,445 yen, even though the total win rate was still 53.3%. That number made me pause a bit, because more trades won than lost, and yet the day still bled out.For this series ledger, I am treating the pasted history as Day 1: cumulative realized P/L is -1,445 yen. Open unrealized P/L was not included in that total. BoundSniper still had -30 yen floating, and MLScore GF-T4 GB had -124 yen floating, so the unfinished part of the day was not exactly clean either.Bot-by-bot results■ GateGrid AI -703 yenPair: GBPUSD-Closed trades: 4Record: 2W / 2LWin rate: 50.0%Gross profit: +93 yenGross loss: -796 yenPayoff ratio: 0.12Max loss: -432 yen■ BoundSniper +3 yenPair: USDJPY-Closed trades: 3Record: 2W / 1LWin rate: 66.7%Gross profit: +162 yenGross loss: -159 yenPayoff ratio: 0.51Max loss: -159 yen■ MLScore GF-T4 GB -487 yenPair: GBPJPY-Closed trades: 4Record: 2W / 2LWin rate: 50.0%Gross profit: +351 yenGross loss: -838 yenPayoff ratio: 0.42Max loss: -600 yen■ LLMBridgeTrader -258 yenPair: EURUSD-Closed trades: 4Record: 2W / 2LWin rate: 50.0%Gross profit: +135 yenGross loss: -393 yenPayoff ratio: 0.34Max loss: -249 yen■ Total -1,445 yenScope: realized closed trades onlyClosed trades: 15Record: 8W / 7LWin rate: 53.3%Gross profit: +741 yenGross loss: -2,186 yenPayoff ratio: 0.30Max loss: -600 yenToday’s theme: the exit beat the win rateThe headline is not just the loss. The stranger part is that the bots won 8 out of 15 closed trades and still ended at -1,445 yen. A total payoff ratio of 0.30 means the average winner was too small compared with the average loser. I do not think the entry side gets cleared completely, but the exit side is where the damage shows up first.GateGrid AI and MLScore GF-T4 GB both finished at a 50.0% win rate. But GateGrid’s two wins totaled only +93 yen, while its two losses totaled -796 yen. MLScore looked slightly healthier on winners, with +351 yen of gross profit, but the -600 yen loss hit like the kind of print you do not just scroll past.The design notes for GateGrid say the bot is built to leave a reason trail, including messages like AI_SKIP(sess=NY gate=0.50 base_thr=0.54 adj_thr=0.55) and OLLAMA_HOLD. That is exactly the kind of log I wanted beside today’s trades. The MT5 export tells me where the damage happened, but not enough about why the model stayed in, closed there, or failed to avoid the bad sequence.GateGrid AIGateGrid AI was the heaviest drag of the day at -703 yen. The first two exits were small wins, +85 yen and +8 yen, which is fine on paper but too small to matter once the later pair of losses arrived. When I saw -364 yen and -432 yen printed back to back, the earlier +93 yen stopped feeling like progress.This is a payoff problem before it is a win-rate problem. A 50.0% win rate can work if the average win and average loss are balanced, but here the payoff ratio was only 0.12. The grid did take profit when it had a chance, but the losing leg widened far beyond the winning leg. My suspicion is exit timing or trailing behavior, not the mere fact that it entered.The architecture is meant to filter entries through CatBoost and then use Ollama for situational judgment. That design is still attractive, because a bot that can say OLLAMA_HOLD has at least some mechanism for refusing trades. Today’s report, though, only shows the final broker-side outcome. Without the actual decision log, I cannot tell whether the AI wanted to hold, whether the trailing logic waited too long, or whether the grid structure simply accepted too much downside.BoundSniperBoundSniper was the only realized winner, but only by +3 yen. That number almost feels like a joke, not because it is bad, but because it survived while the more complex bots took the larger hits. The first close had a loss plus swap cost, then the next two closes recovered enough to end slightly positive.This bot is not trying to be smart in the same way. It passes TradingView signals to MT5, so the performance review belongs mostly to the upstream strategy and execution reliability. Still, the payoff ratio was 0.51, better than the day’s total, and the largest loss was contained at -159 yen. That boring containment mattered.The open USDJPY- short was still floating at -30 yen at the report cutoff. I did not include that in realized P/L, but I would not ignore it either. BoundSniper’s job is clean execution, and today it did that well enough to avoid becoming the story.MLScore GF-T4 GBMLScore GF-T4 GB had the day’s largest single realized loss at -600 yen. That one trade shaped the whole read. The bot had two winners, +151 yen and +200 yen, so it was not failing every time it touched the market. Still, one oversized loss swallowed both winners and left the bot at -487 yen.This is where the “50% win rate” line becomes almost misleading. Two wins and two losses can be perfectly acceptable, but only if the losses are not three times the wins. The payoff ratio was 0.42, which is not hopeless, yet the max loss was too large relative to the rest of the day.The report also showed an open GBPJPY- sell with -124 yen unrealized at cutoff. That makes the exit question harder to ignore. The closed book already had one oversized stop, and the open book was still underwater. I would want to inspect whether the stop width is static, volatility-adjusted, or simply too generous for the current GBPJPY movement.LLMBridgeTraderLLMBridgeTrader ended at -258 yen, with the same 2W / 2L pattern. The difference is that the losses were smaller than MLScore’s and GateGrid’s largest hits, but the wins were also small. A payoff ratio of 0.34 is still too thin.The bot design says it can return not only BUY / SELL / NONE, but also OPEN, HOLD, CLOSE, and REVERSE, along with confidence, setup type, SL pips, TP pips, and entry or exit reasons. That is the part I most want to read on a day like this. The MT5 comments only preserved LLMBridgeTrader_, so I can see the executed trades, but not the reasoning that led to closing at -144 yen or taking the later +77 yen and +58 yen.For an AI-led bot, the entry is only half the experiment. The more interesting question is whether the model knows when its original idea has expired. Today’s LLMBridge result was not catastrophic, but it still leaned toward small winners and larger losers. That pattern needs a stronger close-or-hold audit.SummaryThe day did not collapse because every bot was wrong. It collapsed because the losing trades were allowed to become too heavy relative to the winners. BoundSniper, the least “AI-planner” style bot, was the only one to end positive, and that is a little uncomfortable.The next review should focus less on signal accuracy and more on the moment each bot decides that a trade is no longer worth holding. That is where the money left the account today.Editor’s note: next time, paste the actual AI decision logs too. The numbers are enough to score the day, but the logs are what turn it into a real LLM trading experiment. 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

June 15, 2026Running log: Day 1Cumulative realized P/L: +282 yenEquity impact including open positions: +46 yenThe portfolio finished green, but the most interesting part of the day was not the profit. It was the restraint. Four MT5 bots ended with +282 yen in realized P/L, yet open positions dragged -236 yen, leaving the equity impact at only +46 yen. That number made the day feel thinner than the win rate suggested.The cleanest lesson came from the logs. BoundSniper executed its TradingView signals cleanly, MLScore allowed one BUY but blocked other high-score candidates, and LLMBridgeTrader had one AI plan rejected because the proposed risk settings were invalid. The line that stuck with me was not a winning exit. It was the safety layer saying: sl_pips out of range: -12.34; reward/risk too low: -1.30.Bot Results■ GateGrid AI +67 yenPair: GBPUSD-Closed trades: 8Record: 6W / 2LWin rate: 75.0%Gross profit: +461 yenGross loss: -394 yenPayoff ratio: 0.39Max closed loss: -264 yenFloating P/L: 0 yen■ BoundSniper Bot +182 yenPair: USDJPY-Closed trades: 2Record: 2W / 0LWin rate: 100.0%Gross profit: +182 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: 0 yenFloating P/L: -34 yen■ LLMBridgeTrader +33 yenPair: EURUSD-Closed trades: 2Record: 2W / 0LWin rate: 100.0%Gross profit: +33 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: 0 yenFloating P/L: -141 yen■ MLScore GF-T4 GB 0 yenPair: GBPJPY-Closed trades: 0Record: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: N/AFloating P/L: -61 yen■ Total +282 yenClosed trades: 12Record: 10W / 2LWin rate: 83.3%Gross profit: +676 yenGross loss: -394 yenPayoff ratio: 0.34Max closed loss: -264 yenFloating P/L: -236 yenEquity impact: +46 yenToday’s Theme: Score Is Not PermissionMLScore GF-T4 GB gave the day a sharper angle. Its guard settings were explicit: score threshold 80, max spread 20 points, max 4 new entries per day, and strategy-level entry limits. Then the live log showed a BUY with score 85.33 marked trade=done, while later candidates such as SELL score 96.24 and BUY score 84.32 were marked trade=blocked. That is a good kind of friction. A high score was not allowed to become an automatic order just because the number looked strong.LLMBridgeTrader showed a similar kind of guardrail, but from a different layer. The AI produced a confident-looking plan: Strong bullish trend with ADX and rising MACD, with signal BUY, action OPEN, confidence 85, and setup trend_follow. Then the validator killed it because sl_pips was negative and the reward/risk calculation was broken. I liked that more than I expected. A model can sound convincing, but the system still needs a boring rule that says no.Later, another LLMBridgeTrader plan did open a BUY: Oversold RSI 33 with bullish zone signal despite bearish trend, confidence 72, setup mean_reversion, SL 15 pips and TP 30 pips. That trade was still open at the report cut and showed -141 yen floating P/L. This is where the day stops being neat. The same bot had a safety layer strong enough to reject a bad AI plan, but the accepted plan still left the biggest floating wound of the day.Bot-by-Bot AnalysisGateGrid AI did the most trading and carried the only closed losses. Six wins out of eight sounds comfortable, but the payoff ratio was only 0.39. The -264 yen loss made me stop for a second, because it outweighed several of the small wins. GateGrid’s design is built around not entering bad environments, using CatBoost and Ollama-style filters, but once a grid leg goes wrong, the loss profile still matters more than the headline win rate.BoundSniper Bot was the clean execution story. The monitor showed public health as OK, and the recent trade decisions were all marked Request executed. It opened a short, closed it, opened a long, closed it, and later opened another short that remained floating at -34 yen. Since this bot is not trying to predict the market itself, I read the day as a clean bridge between TradingView signals and MT5 execution.LLMBridgeTrader was the most revealing bot. Its realized result was 2W / 0L for +33 yen, but the open EURUSD position sat at -141 yen. The AI side did something right by having one bad plan blocked, yet the accepted mean-reversion BUY was still underwater at the cut. The uncomfortable question is not whether the AI can enter. It is whether the exit logic can stop a valid-looking idea from quietly overstaying.MLScore GF-T4 GB had no closed result, but its log was probably the most useful one for design review. A BUY score of 85.33 became a live trade, while higher-scoring or still-qualified signals were blocked. That feels annoying in the moment, but it is exactly the kind of behavior a real-money bot needs. The -61 yen floating loss is small, though I would not ignore it just because the realized P/L is zero.SummaryThe day ended green, but the strongest signal was restraint. The realized win rate was 83.3%, yet the payoff ratio was only 0.34 and the floating drag nearly erased the closed profit. The bots can win trades. The better question now is which guardrails deserve to be stricter, and which ones are already saving the account from trades that looked good on paper. 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

ConclusionToday’s combined result for the four MT5 auto-trading bots was +3 yen. On the surface, that is almost flat, and I paused for a second because the number looks too small to say much. But the inside of the day was not small at all.GateGrid AI finished at -304 yen. The other three bots absorbed that loss with a combined +307 yen, leaving the portfolio slightly positive. This was not a big winning day. It was a day that showed why I do not want to judge these bots by win rate alone.Series status: operation day not supplied / input-based cumulative P&L: +3 yen.Bot-by-bot results■ GateGrid AI -304 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +197 yenGross loss: -501 yenPayoff ratio: 0.10Max loss: -501 yen■ MLScore GF-T4 GB +189 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +202 yenGross loss: -13 yenPayoff ratio: 15.54Max loss: -13 yen■ LLMBridgeTrader +32 yenRecord: confirmed trades onlyWin rate: not calculatedGross profit: +32 yenGross loss: unconfirmedPayoff ratio: not calculatedMax loss: unconfirmed■ BoundSniper +86 yenRecord: aggregate result onlyWin rate: not calculatedGross profit: +86 yenGross loss: unconfirmedPayoff ratio: not calculatedMax loss: unconfirmed■ Total +3 yenRecord: not comparable because reporting depth differs by botWin rate: not comparableGross profit: +517 yenGross loss: -514 yenPayoff ratio: not comparableMax loss: -501 yenToday’s themeThe theme today is simple, but it hurts a bit: win rate lied.GateGrid AI won 4 out of 5 trades. An 80.0% win rate looks clean on paper. MLScore GF-T4 GB, on the other hand, went 1 win and 1 loss, only 50.0%. If I only looked at win rate, GateGrid would look like the better bot.The money said something else. GateGrid AI ended at -304 yen, while MLScore GF-T4 GB ended at +189 yen. The difference was not entry frequency. It was the shape of the exits: one bot let a single loss become too large, while the other kept the losing side almost harmless.The log also makes this day more interesting. MLScore printed: [2026-06-12 22:15:04] GBPJPY M15 | candidate=BUY decision=ENTER signal=BUY score=96.43 trade=done. Later, it also printed a high-score blocked signal: [2026-06-12 22:45:01] GBPJPY M15 | candidate=SELL decision=ENTER signal=SELL score=95.9 trade=blocked. That second line matters. The engine found a candidate, the score was high, but the guard did not let it through. Today, that kind of refusal may have been as valuable as the entry itself.GateGrid AIGateGrid AI ended at -304 yen.The four winning trades were +83 yen, +16 yen, +80 yen, and +18 yen. Total profit was +197 yen. That part was not bad. Then came the -501 yen loss, and I honestly stopped there for a moment. One losing trade erased all four wins and pushed the bot negative.This is the weak point of the day. GateGrid AI can take small profits, but today’s exit behavior did not protect the session. Average profit was 49.25 yen. The largest loss was -501 yen. That gap is too wide for an 80% win rate to rescue.The design of GateGrid AI is not just a plain grid. It combines CatBoost entry gating, local Ollama judgment, ATR checks, spread monitoring, session thresholds, and grid management. The idea is to avoid bad entries and build only when the environment is acceptable. But today’s issue was probably not the entry gate. It was the point where the bot should have stopped holding the pain.For the next iteration, I would look at loss containment before tuning entries. A time-based exit, a tighter grid-level drawdown stop, or a rule that prevents one position from destroying the whole day may matter more than trying to improve the already high hit rate.MLScore GF-T4 GBMLScore GF-T4 GB ended at +189 yen.The trade split was almost too clean: +202 yen and -13 yen. One win, one loss. A 50.0% win rate. And still, this was the best-shaped result of the day.The payoff ratio was 15.54. That is the number I care about here. The losing trade was kept tiny, while the winning trade had enough room to matter. This is what GateGrid AI did not do today.The score log supports that reading. A BUY with score 96.43 went through and was executed. Other SELL candidates with scores above 90 were blocked several times. I cannot say every blocked signal would have lost, but I can say the guard was active. It was not blindly following every high score. That is a good sign for live operation, because a score engine without refusal quickly becomes overconfident.LLMBridgeTraderLLMBridgeTrader ended at +32 yen on the confirmed result.It was not a large contribution, but on a day where GateGrid AI lost 304 yen, even +32 yen had a role. This bot is the one where I most want to keep watching the reasoning, not just the trade result.LLMBridgeTrader is designed to let the AI choose more than BUY, SELL, or NONE. It can decide OPEN, HOLD, CLOSE, REVERSE, and NONE. That means the important question is not only “did it enter correctly?” The better question is “did it know when to stop holding?”Today’s confirmed +32 yen is small, but the experiment remains valuable. Once the full OPEN / HOLD / CLOSE / REVERSE logs are reviewed trade by trade, the real story will be whether the AI’s exit reason matched the actual price behavior. That part still needs more evidence.BoundSniperBoundSniper ended at +86 yen.BoundSniper is different from the AI-heavy bots. It receives TradingView signals through a webhook and sends the corresponding orders to MT5. Its job is not to predict the market. Its job is to execute the signal path cleanly.The recent monitor showed OPEN_LONG and CLOSE_LONG events being executed, with Request executed appearing on both order send and position close. That is boring in the best possible way. On a live bot, boring execution is useful.Today, BoundSniper did not need to be the star. It just had to be different from GateGrid AI, and it was. That +86 yen helped turn a losing single-bot day into a barely positive portfolio day.SummaryThe total was only +3 yen, but the day gave me a clear read. GateGrid AI had the higher win rate and still lost. MLScore GF-T4 GB had the lower win rate and won because the loss stayed small.The next improvement target is not “more wins.” It is the size of the one bad loss. If GateGrid AI can reduce that -501 yen type of trade, the same 4W / 1L day could look completely different.Today was not a strong profit day. It was a useful warning disguised as a tiny green number. 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

Turning Red Days into Training Data: The June 11th AI Bot TestIn today’s episode, we break down the June 11th live test of our four MT5 automated trading bots. The portfolio ended the session with a total realized loss of -1,295 JPY, representing a daily return of about -0.75%. But as we discuss in today’s podcast, in the world of machine learning, a losing day isn’t just a failure—it’s highly valuable, labeled training data.We dive into the completely different behaviors of each bot to uncover what went wrong and what went right:* GateGrid AI (GBPUSD): The only profitable bot of the day, securing a clean +279 JPY. It perfectly executed two short trades with zero losses, proving that its strict, multi-layered entry filtering works effectively to capture controlled profits.* BoundSniper (USDJPY): Finished at -282 JPY. With one win and one loss, it highlighted that while the MT5 execution layer is working, the upstream TradingView signal logic needs a better risk-to-reward balance.* LLMBridgeTrader (EURUSD): Ended at -283 JPY. Despite maintaining a 50% win rate across six trades, the size of the losses simply outweighed the wins. It clearly showed that while the AI can make winning decisions, its overall expectancy and risk-reward structure still require adjustment.* MLScore GF-T4 (GBPJPY): Took the hardest hit of the day at -1,009 JPY from two stopped-out trades. However, this provided the clearest and most valuable learning sample for our machine learning model. These clean losing patterns are exactly the feedback the model needs to analyze what market structures failed and improve its future predictions.The ultimate goal of this project isn’t to perfectly avoid losing days—that is impossible. The real goal is to build automated systems that record, analyze, and learn from them. Join us as we explore how we use a “data-rich” red day to build smarter trading bots!#FX #MT5 #AITrading #MachineLearning #AlgorithmicTrading #SystemTrading 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

In today’s episode, we break down the June 10th parallel test of our four MT5 automated trading bots. The total realized profit for the day was a modest +333 JPY, representing a +0.19% return on the portfolio. While it wasn’t a massive windfall, this session perfectly demonstrated a vital concept: the power of diversification.We dive into the performance of each bot to see how portfolio structure mattered more than individual bot performance:* GateGrid AI (GBPUSD): The only losing bot today, finishing at -153 JPY. It opened positions on both the buy and sell sides but was caught in a difficult zone without enough follow-through, signaling a need to review its dual-position exit logic.* BoundSniper (USDJPY): The most stable performer of the day. Acting as a pure execution bot, it closed three clean, winning trades for +172 JPY. It proved that sometimes simple, rule-based execution beats complex AI planning.* LLMBridgeTrader (EURUSD): Delivered the highest absolute profit of +182 JPY. It caught several great trades, but a late -193 JPY loss reduced its earlier gains, highlighting the need for stronger “daily profit protection” rules once a target is reached.* GBPJPY Bot: Added a +132 JPY profit to the portfolio. While it was only a single closing transaction, it perfectly executed its role by helping offset the losses from GateGrid AI.The biggest lesson from today’s session? One bot lost, but the portfolio still won. By running completely different logics—rule-based execution, AI-driven trade planning, and machine-learning grid filters—across multiple currency pairs, we absorbed individual weaknesses and maintained a positive balance.Join us as we discuss why a controlled, diversified green day is the ultimate goal for a live automated trading system!#FX #MT5 #AITrading #AlgorithmicTrading #Diversification #RiskManagement 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

In today’s episode, we break down the June 9th parallel test of our four MT5 automated trading bots. The portfolio ended the session with a combined realized loss of -1,432 JPY. At first glance, it looks like a simple losing day, but the detailed results revealed exactly what we need to do next to improve our systems.We dive into the distinct performances of each bot to uncover why live data is far more valuable than historical optimization:* GateGrid AI (GBPUSD): The main source of today’s deficit, suffering a -1,602 JPY loss on a single trade. This taught us a critical lesson: actual execution quality—such as spreads, volatility, and LLM judgment delays—can drastically alter real-world outcomes. Moving forward, we are running this bot at 0.01 lot to measure its true Expected Value (EV) in live conditions for the next few weeks.* BoundSniper (USDJPY): Finished at -278 JPY. Despite maintaining a good win rate with two winners and one loser, the single losing trade wiped out the gains. It serves as a textbook example of why win rate alone isn’t enough, highlighting the urgent need to rebalance its payoff ratio and exit rules.* LLMBridgeTrader (EURUSD): Ended almost perfectly flat at -6 JPY when factoring in unrealized profits. It effectively avoided large losses, suggesting that its AI-driven position management for holding and closing trades is functioning as a solid defensive mechanism.* MLScore GF-T4 GB (GBPJPY): The undisputed MVP of the day, securing a solid +496 JPY realized profit and reaching +615 JPY with open positions included. It successfully capitalized on the high volatility of GBPJPY, effectively carrying the weight of the entire portfolio today.The ultimate takeaway from today’s session is that while past optimization shows what worked historically, live trading shows what is working right now. Today’s loss was not just a loss—it was highly valuable data.Join us as we discuss our strategic pivot toward live EV measurement and how we use red days to build smarter bots!#FX #MT5 #AITrading #AlgorithmicTrading #MachineLearning #SystemTrading 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

In today’s episode, we break down the June 8th parallel test of our four MT5 automated trading bots. The portfolio ended the day with a solid realized profit of +1,189 JPY. But the real success story wasn’t just about the money we made—it was about the money we didn’t lose, thanks to our newly implemented safety layers.We dive into the performance of each bot to see how they executed their distinct roles perfectly:* GateGrid AI (GBPUSD): The top earner of the day, securing +643 JPY. It executed two highly efficient, short-term trades and closed them quickly in profit, leaving no open exposure.* BoundSniper (USDJPY): Finished at +294 JPY. It perfectly demonstrated the resilience of rule-based execution, absorbing two tiny initial losses (-4 JPY each) before catching three solid profitable exits.* MLScore GF-T4 (GBPJPY): Secured a +252 JPY realized profit on a short trade while holding only a microscopic -7 JPY open drawdown.* LLMBridgeTrader (EURUSD): The most important bot of the day—because it didn’t trade at all. While the LLM generated three “BUY” signals, our newly built Machine Learning (ML) safety gate blocked every single one of them due to candidate and direction mismatches.The ultimate lesson from today’s session is simple: in automated trading, a blocked trade can be just as valuable as a winning trade. Our portfolio won today not by being aggressive, but by letting each bot do its job and allowing the ML gate to say “no” when confirmation was missing.Join us as we discuss how giving our AI bots the power to hit the brakes is taking our system stability to the next level!#FX #MT5 #AITrading #MachineLearning #AlgorithmicTrading #RiskManagement 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

In today’s episode, we review the weekly performance of our four MT5 automated trading bots from June 1 to June 5. The portfolio ended the week with a combined realized loss of -3,307 JPY. While it wasn’t a profitable week financially, it was arguably our most valuable week for system development.We break down each bot’s behavior to understand why giving AI complete autonomy is a risky game, and why the ultimate feature of a trading bot is a reliable “brake”:* GateGrid AI: The clear winner of the week, finishing at +707 JPY. Its multi-layered filtering system proved that a bot’s true power lies not only in finding entries, but in its ability to say “do nothing” and avoid bad trades.* BoundSniper: Finished at -868 JPY. As a pure execution bot, its losses confirmed that the MT5 execution layer is doing its job, but the upstream TradingView signal logic needs serious refinement and better filtering.* LLMBridgeTrader: Took a hard hit at -1,399 JPY. It clearly demonstrated that giving an AI full autonomy over position management (OPEN, HOLD, CLOSE, REVERSE) is dangerous without a strict “ML gate” to reject weak trading plans before they reach the market.* MLScore GF-T4: Ended at -1,747 JPY. It exposed a critical structural flaw: re-entering the market under the same unfavorable conditions immediately after a stop-loss. It highlighted the urgent need for re-entry logic, cooldown rules, and daily risk limits.The biggest takeaway from this week? AI can create brilliant trading plans, but the system still needs the final authority to hit the brakes. Join us as we discuss how we are using this week’s “valuable losses” as direct training and debugging data to build smarter, safer trading systems!#FX #MT5 #AITrading #AlgorithmicTrading #MachineLearning #SystemTrading 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

In today’s episode, we break down the June 5th parallel test of our four MT5 automated trading bots. The portfolio finished the session with an overall loss of -1,068 JPY. At first glance, it looks like a tough day. But for an AI-driven project, a red day with a clear diagnosis is far more valuable than a lucky green day.We dive into the distinct behaviors of each system and the major structural upgrades they inspired:* GateGrid AI (GBPUSD): The only profitable bot today, securing +199 JPY. Its conservative, multi-layered decision structure (combining CatBoost and Ollama) proved its worth by taking small profits and effectively staying out of trouble.* BoundSniper (USDJPY): Finished with a minor -100 JPY loss. As a pure execution bridge, its loss simply tells us that the upstream TradingView signal logic needs better exit controls, rather than indicating an execution failure.* LLMBridgeTrader (EURUSD): Took the hardest hit at -675 JPY. The AI’s immense freedom became a liability. In response, we discuss our massive upgrade: implementing a Machine Learning (ML) Gate powered by CatBoost to strictly filter the LLM’s “OPEN” and “REVERSE” trade plans before they reach MT5.* MLScore GF-T4 (GBPJPY): Ended at -492 JPY, but received the biggest structural overhaul. We’ve upgraded this bot to differentiate between “Breakout” (trend-following) and “Range” (mean-reversion) setups. With new historical backfill data, strategy-specific TP/SL settings, and strict daily safety limits, it’s evolving from a bot that simply guesses into a bot that learns from its logs.The ultimate lesson from today’s session is that our systems are shifting toward a new phase of development. Join us as we discuss how we are literally turning today’s financial losses into tomorrow’s training data!#FX #MT5 #AITrading #MachineLearning #AlgorithmicTrading #SystemTrading 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

In today’s episode, we break down the June 4th parallel test of our four MT5 automated trading bots. The portfolio ended the session with a total realized loss of -550 JPY, or -916 JPY when factoring in open positions. While the result wasn’t dramatic, the day provided a crystal-clear split between our systems: the strictly filtered bots won, while the autonomous AI bots struggled.We dive into the completely different behaviors of each bot to uncover why AI needs strict boundaries:* GateGrid AI (GBPUSD): Delivered the cleanest performance of the day. It secured two wins for +197 JPY and ended the session completely flat with no open exposure. It perfectly executed what a grid-style bot should do: get in, get out, and avoid unnecessary risks.* BoundSniper Bot (USDJPY): Finished in the green at +38 JPY. Acting as a simple executor for TradingView signals, it took an early hit but successfully recovered through a 75% win rate across four trades.* LLMBridgeTrader (EURUSD): Ended with a -281 JPY realized loss. As our most autonomous bot—capable of deciding whether to open, hold, close, or reverse—its flexibility became its downfall today. The AI’s decisions failed to produce a stable expectancy, proving that it desperately needs stricter filtering around confidence and stop-loss distances.* MLScore GF-T4 GB (GBPJPY): Took the heaviest hit, suffering a combined realized and floating loss of -828 JPY. The biggest issue wasn’t just the stop-loss; it was the fact that the bot immediately re-entered the market under the same difficult conditions. It highlighted the urgent need for a “cooldown rule” to prevent immediate re-entries after large losses.The ultimate takeaway from today’s session is simple but profound: Automation should not only decide when to enter. It must also know when not to continue. Giving AI freedom is powerful, but without structured risk filters and “brakes,” that freedom can quickly destroy your edge.Join us as we discuss the “heavy homework” ahead and how we plan to build these crucial safety nets for our autonomous bots!#FX #MT5 #AITrading #AlgorithmicTrading #RiskManagement #MachineLearning 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

In today’s episode, we break down the June 3rd parallel test of our four MT5 automated trading bots. The portfolio ended the session with a combined result of -999 JPY. At first glance, it looks like a simple losing day, but for our AI and machine-learning-based systems, these results provide invaluable training material.We dive into the completely different profiles of each bot to see what we learned:* GateGrid AI (GBPUSD): The cleanest and strongest performer of the day, securing +133 JPY. It perfectly demonstrated its selective design philosophy by taking exactly one trade, winning it, and leaving no open exposure. It proved that a bot’s real value often lies in deciding when not to enter.* BoundSniper (USDJPY): Finished at -584 JPY. Despite having a high win rate with 5 winning exits and 2 losing exits, the losses were simply too large. It serves as a stark reminder that a good win rate means nothing if your average loss isn’t strictly controlled.* LLMBridgeTrader (EURUSD): Ended slightly negative at -147 JPY. Because this bot relies on high AI autonomy (deciding to OPEN, HOLD, CLOSE, or REVERSE), today’s results showed that it still needs stricter guardrails and better confidence filtering around its stop-loss placement.* MLScore (GBPJPY): Closed at -401 JPY. It had two winning exits, but one oversized loss dominated the day. However, because MLScore accumulates learning data, this specific loss is crucial feedback that will help the bot avoid similar bad setups in the future.The biggest takeaway from today’s session is that for bots like GateGrid and MLScore, every trade is feedback. A losing day might be painful, but if the logs are used to refine the models, today’s losses will literally become tomorrow’s filters.Join us as we discuss how we turn a red day into smarter trading logic!#FX #MT5 #AITrading #AlgorithmicTrading #MachineLearning #SystemTrading 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

In today’s episode, we break down the June 2nd parallel test of our four MT5 automated trading bots. It was a tough session across the board, with the total realized loss hitting -1,429 JPY, and the overall equity impact reaching -1,567 JPY when including floating losses. However, from a system-evaluation perspective, it was an incredibly useful day. Today, the main question wasn’t about who won, but rather: “Which bot lost in the most controlled way?”.We dive deep into the completely different loss profiles of each bot to understand their structural weaknesses and strengths:* LLMBridgeTrader (EURUSD): The winner among the losing bots. It ended with the smallest realized loss of -185 JPY. It successfully demonstrated that its risk management can contain the damage when AI judgments or market conditions turn unfavorable.* GateGrid AI (GBPUSD): Finished at -206 JPY. While it showed resilience by securing small wins (+81 JPY and +19 JPY) earlier in the day, a single larger loss of -306 JPY pushed it into negative territory, highlighting the importance of preventing one bad trade from overpowering multiple wins.* BoundSniper Bot (USDJPY): Ended at -438 JPY. Since its job is purely to execute TradingView signals, today’s drawdown was not an execution failure, but a signal-quality issue. It serves as a reminder that upstream logic needs robust filters for choppy or reversing sessions.* MLScore GF-T4 GB (GBPJPY): The main source of today’s drawdown, closing with a -600 JPY realized loss and carrying a -138 JPY floating loss for a total impact of -738 JPY. We discuss why its risk-reward structure requires an urgent review, especially since the reward target is relatively tight compared to the stop range.Join us as we discuss why we aren’t stopping the test, but instead tightening our review loop. Because in automated trading, controlled losses are often far more valuable for improving systems than easy profits.#FX #MT5 #AITrading #AlgorithmicTrading #RiskManagement #TradingStrategy 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

In today’s episode, we break down the June 1st parallel test of our MT5 automated trading bots. The portfolio ended the day with a solid realized profit of +739 JPY (or +757 JPY including floating profit), winning an impressive 12 out of 13 closed trades. But the real story isn’t just about an easy winning day—it’s about how portfolio diversification protected our profits.We dive into the performance of each bot to see how their distinct architectures worked together:* GateGrid AI (GBPUSD): The strongest performer of the day. It secured +384 JPY across 4 flawless wins. Its complex design—combining model-based filtering, local AI judgment, and volatility checks—proved that its greatest strength is effectively avoiding low-quality entries.* MLScore GF-T4 (GBPJPY): Delivered the cleanest execution. It took one single trade and successfully hit its take-profit for +250 JPY, leaving no open positions or floating risks behind.* BoundSniper (USDJPY): Quiet and consistent. Acting as a disciplined rule-based executor, it closed 5 winning trades for +216 JPY. It proved once again that this bot’s true value lies in its strict discipline rather than complex intelligence.* LLMBridgeTrader (EURUSD): The only bot to struggle, ending with a -111 JPY realized loss. Despite winning two out of three trades, a single large stop-loss outweighed its combined gains, highlighting the ongoing challenge of risk asymmetry when an AI acts as a trading planner.The biggest lesson from today’s session is clear: a single AI bot can be fragile, but a diversified group of bots is resilient. Because we ran rule-based execution, AI planning, machine-learning scoring, and grid-style filtering simultaneously, the overall portfolio easily absorbed LLMBridgeTrader’s weak performance and remained comfortably positive.Join us as we discuss why a multi-bot structure makes individual weaknesses easier to see and manage, and why an imperfect day can still be a highly useful win.#FX #MT5 #AITrading #AlgorithmicTrading #Diversification #RiskManagement 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