AI FX Bot Lab: Real Trading Experiments

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

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 would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we introduce the newest addition to our automated trading lineup: ML_ScoreAnalyst. Running on a real account, this bot targets the highly volatile GBPJPY 15-minute chart (M15). However, the core focus of this episode isn’t about how often it trades, but rather why it rejects most of the setups it finds.We dive into the architecture of this new “score-based” trading bot and what makes it fundamentally different from our previous systems:* Candidate vs. Decision (The Scoring System): ML_ScoreAnalyst doesn’t just blindly fire orders when a condition is met. First, it identifies a breakout candidate based on price action and ATR. Then, it passes that data to a CatBoost machine learning model, which calculates an entry probability score from 0 to 100. If the score doesn’t beat our strict threshold, the bot logs the decision as a “SKIP” and stays out of the market.* Built for Continuous Evolution: This is not a “set and forget” system. Every decision and its underlying market features are saved to a CSV log. This creates a continuous feedback loop where we can back-test different Stop Loss (SL) and Take Profit (TP) combinations, label the outcomes, and retrain the CatBoost model with verified live data.* Multi-Layered Safety Checks: Operating on a live account requires extreme caution. We discuss the strict, multi-layered safety protocols built into the bot, including preventing duplicate orders on the same candle, checking broker filling modes, and strictly isolating Dry Run, Demo, and Real account environments to prevent catastrophic execution errors.The ultimate value of a trading bot isn’t just in its entry logic, but in its ability to selectively stay out of unfavorable conditions. Join us as we explore the mechanics of ML_ScoreAnalyst and why an intelligent “SKIP” is often the most profitable decision a bot can make.#FX #MT5 #MachineLearning #AlgorithmicTrading #CatBoost #SystemTrading #GBPJPY This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

Simple Rules Beat Advanced AI: The May 25–29 Weekly Bot ReviewIn today’s episode, we review the weekly performance of our three MT5 auto-trading bots from May 25th to May 29th. The portfolio ended the week in the red at -1,560 JPY, but the contrasting results gave us a fascinating and unexpected insight: sometimes, simple rules completely outperform advanced AI.We break down the distinct behaviors of each bot to understand what went right and what went wrong:* BoundSniper Bot: The only profitable bot this week, securing +393 JPY. Acting purely as a rule-based executor with no AI, it stuck faithfully to TradingView signals without hesitation. It proved that simple execution can avoid large losses and provide ultimate stability, though we also learned the importance of monitoring overnight swap costs that can silently eat into small profits.* GateGrid AI: Finished the week at -913 JPY. Despite a strong defensive showing early in the week, a single hard hit of -765 JPY wiped out all of its accumulated gains. It perfectly demonstrated the classic weakness of grid trading: when one single loss exceeds your average win, the total ends up negative.* LLMBridgeTrader: Our most experimental, fully AI-driven planner took the hardest hit, ending at -1,040 JPY. Because the AI is given full discretion over position management (OPEN, HOLD, CLOSE, REVERSE), a run of bad calls caused the drawdown to balloon rapidly. However, it showed encouraging resilience by clawing back some profit at the week’s end, highlighting the urgent need to build tighter “guardrails” and maximum loss caps.The ultimate lesson from this week? A good automated trading bot isn’t just judged by the size of its profits, but by how it loses and where it manages to stop the damage.Join us as we discuss why our simplest bot won the week, and outline our specific plans to completely rework the exit strategies for our AI models moving forward.#FX #MT5 #AITrading #AlgorithmicTrading #SystemTrading #TradingStrategy This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we break down the results from the May 29th parallel test of our three MT5 automated trading bots. The portfolio ended the day with a minor deficit of -109 JPY. At first glance, a negative result might seem disappointing, but from a system-development perspective, it was an incredibly useful day.We dive into the distinct behaviors of each bot to uncover why a small, controlled loss is actually a long-term win:* GateGrid AI (GBPUSD): Finished at -37 JPY. The bot opened a short position and managed to close it quickly after the market moved slightly against it. For a grid-style bot, limiting losses like this is crucial to prevent a bad grid sequence from growing out of control.* BoundSniper Bot (USDJPY): Barely broke even at +2 JPY. While the actual trading logic was correct and generated a +19 JPY profit, overnight swap costs nearly wiped it out. This serves as a vital reminder: a bot can be directionally correct, but still lose its edge due to the hidden costs of holding. We discuss the need to track holding time and swap impact moving forward.* LLMBridgeTrader (EURUSD): Ended the day at -74 JPY. It started with a frustrating carryover loss (also impacted by swap fees), but later demonstrated impressive resilience by opening a new long position and securing a +126 JPY win. While it didn’t fully recover, it showed that AI-driven position planning can bounce back from early drawdowns.The ultimate takeaway from today’s session is simple: a good trading bot is not just judged by its profits. It is judged by how it loses, how effectively it limits damage, and whether its logs provide clear points for the next improvement.Join us as we discuss how we plan to tighten control over carryover risks and swap impacts for our upcoming sessions!#FX #MT5 #AlgorithmicTrading #AITrading #RiskManagement #SystemTrading This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we break down the results from our May 26th parallel test of three MT5 automated trading bots. While the combined realized profit and loss was nearly flat at -24 JPY, the underlying details tell a very different story about risk and bot behavior.We dive into the distinct performances of each bot to see why rigid logic beat AI autonomy today:* GateGrid AI (GBPUSD): The standout performer of the day. It closed two clean, profitable trades for a realized P&L of +193 JPY, with no open positions left at the end of the session. Its defensive design—requiring strict alignment between the CatBoost gate, volatility conditions, spread, and local AI judgment—worked perfectly to filter out bad setups.* BoundSniper (USDJPY): The king of consistency. Acting purely as an execution bot for TradingView signals, it secured +60 JPY with a 100% win rate on its closed trades. It did exactly what it was built to do: follow the rules, close small profits, and avoid unnecessary complexity.* LLMBridgeTrader (EURUSD): The day’s weakest link. As our most experimental and autonomous bot—allowing the AI to decide whether to OPEN, HOLD, CLOSE, or REVERSE—its flexibility became a liability. It closed two losing trades for -277 JPY and carried an open short position with an unrealized loss of -153 JPY. It clearly showed that the AI planner needs stronger risk filters and better stop-loss logic.The biggest takeaway from this session is that stability matters more than autonomy. A relatively flat day perfectly highlighted how different bot architectures react to the exact same market conditions, proving that steady rules often outperform aggressive flexibility.Join us as we discuss our next steps, including how we plan to enforce stricter confidence thresholds and exit logic on LLMBridgeTrader while maintaining the reliable performance of our more controlled bots.#FX #MT5 #AlgorithmicTrading #AITrading #RiskManagement #TradingStrategy This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we dive into the May 25th parallel test results for our three MT5 automated trading bots. The portfolio ended the day slightly in the red, with a total realized loss of -228 JPY, or -272 JPY when factoring in open positions. While it wasn’t a winning day, it was an incredibly useful one.We break down the distinct behaviors each bot exhibited under imperfect market conditions:* LLMBridgeTrader (EURUSD): The strongest performer of the day. It successfully secured a +254 JPY profit. The bot perfectly executed what we want from an AI-driven system: it didn’t overtrade, it took one solid position, and it protected the trade by moving the stop into profit before ending the day cleanly.* BoundSniper Bot (USDJPY): A crucial lesson in equity management. While it closed the day with a +25 JPY realized profit across three trades, it held an open position with a floating loss of -44 JPY. It’s a stark reminder that realized profit alone isn’t enough—floating P/L matters just as much.* GateGrid AI (GBPUSD): The source of today’s overall deficit, taking a -507 JPY hit on a single short trade that moved roughly 31.9 pips against it. We discuss our plans to review the logs to understand why the CatBoost and Ollama filters allowed this entry, and whether the session threshold was too loose or volatility was increasing.A robust automated trading system shouldn’t only be judged by whether it wins every day. Join us as we explore why this “valuable small loss” provides the exact clarity we need to refine our entry filters and position handling.#FX #MT5 #AlgorithmicTrading #AITrading #RiskManagement #TradingStrategy This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we share our strategic blueprint for this week’s MT5 automated trading sessions. Building on the biggest lesson from last week’s parallel tests—that a bot’s true value lies not in its win rate, but in how effectively it minimizes losses—our core theme for this week is the “radical enhancement of exit rules and risk management”.Here is how we are upgrading each of our three bots to master the art of the exit:* GateGrid AI: We are thrilled to announce a major upgrade. By implementing the faster, high-performance qwen3.6-40b-deck-opus-neo-code:latest model, we aim to eliminate the 30-second timeout issues we experienced with Ollama last week. This faster processing will drastically improve the bot’s ability to quickly assess qualitative risks like spreads, ATR, and H1/H4 trends. To overcome the fatal “win small, lose big” grid structure, we are strictly enforcing new stop conditions for adding second-layer grid positions (such as halting when higher timeframe trends reverse or ATR rapidly expands) and implementing strict forced exit rules when holding multiple positions.* LLMBridgeTrader: Operating as our AI-driven trading planner, this bot performed exceptionally well last week by expertly handling OPEN/HOLD/CLOSE/REVERSE position controls. This week, our goal is to protect those profits. We are setting a stricter “maximum allowable loss safety net” over the AI’s proposed trading plans to prevent a single large loss from wiping out the entire day’s gains.* BoundSniper Bot: Our reliable, rule-based execution bot continues to be the stabilizing anchor of our portfolio. While we aren’t changing the bot’s core mechanics, we are optimizing its external TradingView strategies by re-evaluating whether the stop-loss and take-profit widths are appropriate to ensure a steady accumulation of small wins.Armed with the massive amount of log data from last week’s “valuable losses,” this week is all about evolving beyond mere entry selection. Join us as we focus on perfecting “exit control”—the critical skill of executing a graceful escape when the market moves against you.#FX #MT5 #AITrading #AlgorithmicTrading #RiskManagement #TradingStrategy This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s special episode, we look back at the comprehensive 5-day parallel test of our three distinct MT5 automated trading bots. Despite experiencing days with overall win rates of 68% and 57.1%, the portfolio ultimately ended the week in the red. Why? Because a high win rate can be a dangerous illusion.We break down the performance and unique architecture of each bot to uncover the harsh realities of algorithmic trading:* LLMBridgeTrader (EURUSD): The MVP of the week. Operating as an “AI Trading Planner,” it dynamically decides whether to OPEN, HOLD, CLOSE, or REVERSE positions rather than just emitting simple buy/sell signals. It proved that maintaining a strong risk-reward balance—keeping losses incredibly small—is far more effective than just chasing a high win rate.* BoundSniper Bot (USDJPY): Our reliable stabilizer. A purely rule-based bot that faithfully executes TradingView signals without any independent AI market analysis. It steadily accumulated small profits throughout most of the week, proving the value of emotionless, mechanical execution.* GateGrid AI (GBPUSD): The bot that taught us the most painful lesson. Using a hybrid of CatBoost (machine learning) and an Ollama local LLM, it features an incredibly strict entry filter. However, its structural flaw as a grid bot was exposed: it fell into the classic trap of “winning small and losing big” when stacked positions faced adverse market moves.The ultimate takeaway from this 5-day experiment? “Selection power” (filtering entries) and “loss control” (managing exits) are completely different skills. In automated trading, success isn’t defined by how often you win, but by how well you control your losses when the market turns against you.Join us as we explore these architectural differences and discuss our next steps to build stricter safety nets and exit strategies for our AI bots.#FX #MT5 #AITrading #AlgorithmicTrading #RiskManagement #MachineLearning This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we review the May 22nd parallel test results of our three MT5 automated trading bots. The portfolio ended the day with a total loss of -1,571 JPY. Despite a solid win rate, the results highlighted a harsh reality of system trading: it’s not about how often you win, but how you manage your losses.We dive into the specific behaviors of each bot to understand what went wrong and how we plan to fix it:* GateGrid AI (GBPUSD): The biggest struggle of the day, finishing at -1,594 JPY. While its CatBoost and Ollama entry logic is highly cautious, the bot failed after entering the market. Two large stop-losses in the second half of the day wiped out its smaller profits, proving that for grid bots, a strict exit strategy is far more critical than a perfect entry.* BoundSniper Bot (USDJPY): A beacon of stability, ending with a +38 JPY profit across 4 consecutive wins. As a pure execution bot for TradingView signals, it perfectly fulfilled its role as a reliable, rule-based benchmark against our more complex AI bots.* LLMBridgeTrader (EURUSD): A frustrating near-miss, closing at -15 JPY. It secured two solid wins but suffered one large loss that erased its gains. While the AI’s market direction planning seems accurate, its risk management needs a stricter safety net to prevent a single loss from destroying a winning streak.Across all three bots, we had 14 trades with 8 wins and 6 losses—a 57.1% win rate. Yet, we lost money because the size of our losing trades simply exceeded the size of our wins.Join us as we discuss the critical importance of “how to lose.” We outline our next steps, including stricter withdrawal rules for GateGrid AI when multiple positions are caught in an adverse trend, and tighter maximum loss filters for LLMBridgeTrader’s AI plans. It was a losing day, but the path to improvement has never been clearer.#FX #MT5 #AlgorithmicTrading #AITrading #RiskManagement #GridTrading This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we break down the results from the May 21st parallel test of our three MT5 auto-trading bots. The portfolio ended the day with a microscopic net profit of just +60 JPY. At first glance, it might look like a meaningless day, but underneath the surface, it provided some of the most critical insights we’ve had so far.We take a closer look at how each bot behaved under the hood:* LLMBridgeTrader (EURUSD): The star of the day. After stepping up its lot size to 0.02, it smoothly executed four trades—all positive—for a total profit of +824 JPY. It proved the value of its advanced AI logic, which considers confidence, stop-loss proximity, and trade reasoning to think far beyond simple BUY or SELL signals.* BoundSniper Bot (USDJPY): The stabilizer of our portfolio. Trading at a small 0.01 lot, it simply received and executed TradingView signals via webhook, securing a drama-free +93 JPY across three trades. It demonstrated that stable, boring execution is a highly valuable asset in a multi-bot system.* GateGrid AI (GBPUSD): The bot that gave back the profits, ending at -857 JPY. While it successfully accumulated multiple small wins, its two-level grid structure was caught in a painful adverse move. Two significant losses in the second layer (-688 JPY and -744 JPY) wiped out its progress, exposing a clear structural weakness.The ultimate takeaway from this session? Win rate is not enough. Position stacking risk matters more.Join us as we discuss the “painful reversal” of grid-style systems, and outline our specific plans to implement stricter conditional controls on GateGrid AI’s second grid layer—such as blocking additions during adverse higher-timeframe trends or when ATR expands too quickly.#FX #MT5 #AlgorithmicTrading #AITrading #RiskManagement #GridTrading This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we break down the May 20th results of our three MT5 automated trading bots. While the total daily result was a loss of -813 yen, it was far from a total failure. In fact, two out of the three bots ended the day in profit, making this a highly valuable learning experience.We dive into the specific behaviors of each bot to understand what went right and what needs fixing:* BoundSniper Bot (USDJPY): Finished with a steady profit of +60 yen across two winning trades. Functioning purely as an execution bot for TradingView signals, it showed the strength of simply following the rules and securing small wins without unnecessary complications.* LLMBridgeTrader (EURUSD): Ended the day with a +89 yen profit. Designed to let AI control complex position operations like OPEN, HOLD, CLOSE, and REVERSE, its biggest achievement today was keeping its single losing trade to a mere -5 yen. It proved that in automated trading, keeping your losses small is just as important as winning.* GateGrid AI (GBPUSD): The primary cause of the day’s overall deficit, finishing at -962 yen. Despite utilizing advanced tools like CatBoost and Ollama to filter entries strictly, it fell into a classic “win small, lose big” pattern.This episode highlights a crucial lesson: entry filters alone are not enough. We discuss the difficulties of managing grid-based bots when the market moves against you, and why evaluating exit points and grid expansion limits is vital. Join us as we explore why this was a “valuable loss” and outline our upcoming improvements for GateGrid AI’s exit controls and loss management.#FX #MT5 #AlgorithmicTrading #AITrading #RiskManagement #MachineLearning This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In today’s episode, we break down the performance of our three MT5 automated trading bots from the May 19th parallel test. While the total profit was a modest +118 yen, the day provided a masterclass in how different AI architectures handle market volatility.We dive deep into the performance of each bot to see what worked and what didn’t:* LLMBridgeTrader (EURUSD): The standout performer of the day. Acting as a “trading planner” rather than a simple signal generator, it achieved a 91.7% win rate (11 wins, 1 loss) for a profit of +972 yen. Its ability to handle complex position operations—including holding and reversing—proved highly effective.* BoundSniper Bot (USDJPY): Reliability was the theme here. Functioning as an execution bot for TradingView signals, it went 6 for 6 with no losses, contributing a steady +352 yen to the total.* GateGrid AI (GBPUSD): The most challenging result of the day. Despite its advanced filtering using CatBoost and Ollama, it ended with a -1,206 yen loss. The bot struggled with a “small wins, big losses” pattern, highlighting that entry filters alone aren’t enough to manage a grid-based strategy.The biggest takeaway from this session is that “selection power” (filtering entries) and “loss control” (managing exits) are two entirely different skills.Join us as we discuss the specific improvements planned for GateGrid’s loss management and how we intend to categorize LLMBridgeTrader’s successes by setup type to further refine its AI logic. Whether you are interested in ML-hybrid bots or LLM-driven trade planning, this episode offers a transparent look at the front lines of AI trading.#FX #MT5 #AlgorithmicTrading #AITrading #LLM #AssetManagement This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In this episode, we face a harsh reality in algorithmic trading: a high win rate does not guarantee profitability.On May 18th, our portfolio of three distinct bots achieved a solid overall win rate of about 68%, yet the final daily balance ended up negative. How did this happen? While our AI-driven LLMBridgeTrader managed to secure a small profit by keeping its win-loss balance in check, our hybrid bot, GateGrid AI, suffered a massive hit. Driven by the Local LLM (Qwen), the bot took a heavily biased “SELL” position which ultimately hit a double Stop Loss—a classic example of accumulating small wins only to suffer a devastating wipeout.But here is the true power of automated trading: while a human trader might succumb to frustration or revenge trading, a bot simply turns its defeat into data. We discuss how we are using these painful logs to retrain the ML models, teaching the AI to recognize dangerous market conditions and avoid over-committing to one direction.We also cover critical updates to our other bots:* BoundSniper: Why we abandoned fixed 20-pip SL/TP levels to let it act purely as an execution engine for TradingView signals, preventing the bot from interfering with the original strategy.* ML_ScoreAnalyst: Why we are patiently running it in a demo environment, proving that logging “skipped” trades is just as vital as logging executed ones to train a robust model.Tune in to learn why the secret to surviving the market isn’t about building a bot that wins every time, but building a bot that knows how to lose and grows stronger from every defeat.🎧 Episode Highlights:* The High Win Rate Trap: Why a 68% win rate across our bots still resulted in a net loss.* The Danger of One-Sided Positions: Analyzing GateGrid AI’s painful double Stop Loss and the risk of the LLM leaning too heavily in one direction.* Emotionless Evolution: How to use losing trades as crucial data to retrain and improve your AI instead of revenge trading.* Fixing BoundSniper: The reason we removed fixed SL/TP settings to let the bot focus strictly on executing signals.* The Ultimate Lesson: Why controlling the size of your losses matters far more than how often you win.#AlgorithmicTrading #TradingBots #LocalLLM #ForexMarket #MachineLearning #SystemTrading #Python This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

If everyone uses AI to trade, will we all become profitable, or will the market simply stop functioning?. In this episode, we tackle the ultimate question every algorithmic trader faces in the AI era.The short answer is no; a world where everyone wins will never arrive. The market is fundamentally a relative game—for someone to buy at a good price, someone else has to sell. As AI becomes more common, easy and obvious trading edges will be instantly recognized and absorbed into the market price, making simple strategies obsolete.Furthermore, even if an AI accurately predicts market direction, traders will still lose money if they fail at basic money management, such as using excessive lot sizes or ignoring risk-reward ratios. The most dangerous trap is blind overconfidence: assuming an AI is unbeatable just because it performed well in a backtest.To actually survive and thrive, we need to stop handing over total control and instead become strict “supervisors” of our AI. We break down the four crucial steps to improving your AI trading performance:* Data Quality: Filtering out the noise between clean backtest data and messy real-world market conditions.* The Art of Skipping Trades: Why designing an AI to find reasons not to trade is far more important than finding entry signals.* Strict Operational Rules: Establishing clear boundaries for when to trust the AI and when to manually halt it.* Continuous Improvement: Building a system to analyze daily logs and understand exactly why a bot won or lost.Tune in to find out why the true winners in the AI era won’t be those who ask AI to predict the future, but those who use AI to eliminate their own trading weaknesses.🎧 Episode Highlights:* The Zero-Sum Reality: Why the market won’t break even if everyone uses AI bots.* The Disappearing Edge: How the democratization of AI makes finding simple, profitable strategies much harder.* The Biggest AI Trap: Why a high win rate means nothing without human-led risk and lot management.* The 4 Pillars of AI Trading: Data quality, trade avoidance, operational rules, and continuous log analysis.* The Ultimate Takeaway: Why your job isn’t to let AI trade for you, but to supervise it to prevent sloppy losses.#AlgorithmicTrading #SystemTrading #AITrading #ForexMarket #LocalLLM #Python #TradingBots This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In algorithmic trading, the hardest decision isn’t setting the rules—it’s knowing exactly when to stay out of the market. Breakout patterns often look promising on the chart, but relying solely on breaking past highs or lows can easily trap you in fakeouts and emotional trading.To solve this, we are introducing the 4th trading bot to our portfolio: BotML_ScoreAnalyst, specifically designed for the GBP/JPY 15-minute timeframe. Unlike traditional bots that blindly execute signals, this bot acts as a strict “Evaluator”.First, it identifies potential entry candidates using a 20-candle high/low breakout, but with a crucial twist: it requires a volatility spike—an ATR multiplier of 1.1x or higher—to confirm true momentum. Then, a Machine Learning model evaluates the setup based on features like candle shapes, spreads, and recent returns, assigning it a probability score from 0 to 100. If the score hits the threshold of 65 or higher, the bot executes a fixed 30-pip Stop Loss and Take Profit order; otherwise, it strictly skips the trade.But the true magic of this bot lies in its continuous learning mechanism. It logs every single candidate, including the ones it skipped, and tracks future price action to determine whether those skipped trades would have eventually hit Take Profit or Stop Loss. This “what-if” data is then fed into a retraining batch to continuously optimize the model, SL/TP levels, and scoring thresholds.Tune in as we break down how to stop relying on gut feelings and start using ML-driven scores to master breakout trading.🎧 Episode Highlights:* The Breakout Dilemma: Why simply crossing recent highs/lows is a trap without a proper volatility filter.* The ML Grading System: How the bot scores setups from 0 to 100 and uses a 65-point threshold to separate the signals from the noise.* Learning from Inaction: Why logging skipped trades is the ultimate secret to building a robust dataset for model retraining.* The Portfolio Role: Where this “Evaluator” bot fits alongside our Rule-Based, AI-Driven, and Hybrid Grid bots.#AlgorithmicTrading #MachineLearning #ForexTrading #GBPJPY #Python #TradingBots #SystemTrading This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

In this episode, we dive into the ultimate algorithmic trading experiment: pitting three completely different MT5 FX trading bots against each other in the live market. Is a pure rule-based system better? Should we hand over the steering wheel entirely to AI? Or is a hybrid approach the key to surviving market volatility?We review the distinct design philosophies and real-world performance of these three bots leading up to mid-May:* GateGrid AI (ML + Local LLM Hybrid): Designed to find reasons not to enter a trade using CatBoost and Ollama. It showed incredible potential, securing a massive 88.9% win rate and a +928 JPY profit on May 14th. However, it also revealed the classic grid-bot dilemma—balancing consistent small wins against the risk of sudden, deep losses.* LLMBridgeTrader (AI-Driven Planner): This bot gives full control to the AI to plan entries, exits, and even determine Stop Loss/Take Profit levels, backed by a system-level fail-safe. Surprisingly, it proved to be the most resilient, maintaining a steady, positive balance (+113 JPY on May 14th, +198 JPY on May 15th) by keeping losses minimal.* BoundSniper (Strictly Rule-Based): A pure execution bot following TradingView signals without any AI intervention. Despite a decent win rate, it struggled significantly with its risk-reward ratio, highlighting the danger of range-based logic getting caught in strong trend breakouts.Tune in as we break down the data and reveal the most crucial lesson in automated trading: why a high win rate doesn’t guarantee a profitable day, and why controlling how you lose is far more important than how often you win.🎧 Episode Highlights:* The setup: Comparing Rule-Based vs. AI-Driven vs. Hybrid trading bots.* The Grid Bot trap: Why GateGrid AI’s 88.9% win rate still requires strict loss control.* Trusting the AI: How LLMBridgeTrader successfully managed risk and stayed profitable.* The ultimate takeaway: Why managing the size of your losses is the true secret to surviving algorithmic trading.#AlgorithmicTrading #LocalLLM #TradingBots #Python #SystemTrading #ForexMarket #AIInvestments This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com

【Episode Summary】 In this episode, a system trader in his 40s shares his raw, unfiltered journey of trading his entire life savings for true “freedom” and why he is now dedicated to FX algorithmic trading using Local LLMs.After ending a 10-year marriage, the invisible chain of “marital expenses” weighed heavily on him. To break free, he made the ultimate decision to surrender his stable career as a teacher, his severance pay, and almost all his savings. Looking at his bank account balance reduced to double digits, he felt no despair—only the realization that “freedom is expensive”.He then transitioned into a web engineer, finding solace in programming where “if you write it right, it works right,” and spent his nights facing FX auto-trading charts. After a life full of detours, he has now returned to the classroom as a temporary instructor, armed with real-world wisdom he can share with his students.In an era dominated by cloud AI, why does he insist on using a “Local LLM” built entirely on his own PC? His reason is profoundly personal: he is simply tired of depending on anything else in life. Building and controlling a trading bot with his own hands reflects his ultimate stance on life.Whether you are feeling stuck in life or interested in the deeply personal philosophy behind AI development, this documentary-style episode offers a unique perspective on regaining control of your destiny.🎧 Episode Highlights:* Surrendering stability and life savings to buy “freedom”.* Finding salvation in code and numbers during solitary nights as an engineer.* The valuable lessons learned from a life full of detours.* Why a “Local LLM” is the ultimate choice for a truly independent life.#AlgorithmicTrading #LocalLLM #Python #SystemTrading #LifeJourney #Independence This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com