Conclusion

The combined closed result was +528 yen, so the day ended positive. Still, the clean number hides the part I kept staring at: the largest single loss was -414 yen on BoundSniper. A day can finish green and still leave a clear warning mark.

LLMBridgeTrader was the strongest performer, with six closed winners and no losing trade. GateGrid AI also ended positive, but its payoff ratio was only 0.31, which tells a different story from the surface result. MLScore GF-T4 GB slipped into a realized loss and still had one open GBPJPY short carrying a floating loss at the report cut-off. The theme today was not “how many trades won.” It was whether each bot knew when to stop holding.

Bot-by-Bot Results

■ GateGrid AI +307 yenRecord: 13W / 3L / 1 flatWin rate: 81.3%Gross profit: +1,210 yenGross loss: -903 yenPayoff ratio: 0.31Max loss: -364 yen

■ LLMBridgeTrader +710 yenRecord: 6W / 0LWin rate: 100.0%Gross profit: +710 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen

■ MLScore GF-T4 GB -303 yenRecord: 1W / 2LWin rate: 33.3%Gross profit: +200 yenGross loss: -503 yenPayoff ratio: 0.80Max loss: -252 yenOpen position: -94 yen floating loss

■ BoundSniper -186 yenRecord: 3W / 1LWin rate: 75.0%Gross profit: +228 yenGross loss: -414 yenPayoff ratio: 0.18Max loss: -414 yen

■ Total +528 yenRecord: 23W / 6L / 1 flatWin rate: 79.3%Gross profit: +2,348 yenGross loss: -1,820 yenPayoff ratio: 0.34Max loss: -414 yenOpen position: -94 yen floating loss

Today’s Theme: The Exit Was Louder Than the Entry

Today was one of those sessions where the final P/L looks fine, but the structure feels uneven. The total closed result was positive, yet the payoff ratio for the whole group was only 0.34. That means the average winning trade was much smaller than the average losing trade. I do not want to overreact to one day, but that number is low enough to make me slow down.

The LLM-based bots are not only entry machines in this experiment. Especially for LLMBridgeTrader and GateGrid AI, I am watching whether the model or the surrounding logic can decide when to stop holding, when to close, and when to reverse. Today, the entry side was not the main concern. The exit layer was where the personality of each bot showed up.

GateGrid AI

GateGrid AI finished at +307 yen, which is a decent outcome on paper. But the path was not as comfortable as the headline result. The bot had 13 winning exits, 3 losing exits, and 1 flat exit, yet the payoff ratio stayed at 0.31. That usually means the system is collecting small pieces and occasionally giving back a large chunk. The -364 yen loss made me pause, because this pattern can look stable right until it is not.

There was also a useful detail inside the loss structure. The large losing legs were partly offset by companion winners in the same grid cycle. For example, a -360 yen leg was softened by +203 yen and +155 yen exits, and later a -364 yen leg was offset by +214 yen and +158 yen. So the grid did not break; it absorbed. Still, absorption is not the same as control. The next improvement probably sits around how quickly the weak leg is cut, or whether the cluster should be closed earlier when one side starts dragging the whole basket.

For a CatBoost plus Ollama design, this is exactly the kind of day worth logging. The model did enough to stay positive, but the exit rules were forced to carry the risk. I would not call it a bad day. I would call it a warning wrapped in a profit.

LLMBridgeTrader

LLMBridgeTrader was the cleanest bot today: +710 yen, six closed winners, no losing trade. The interesting part is that several exits were tagged as stop-related closes, but they ended in profit. That suggests the exit layer was not just cutting damage; it was locking in movement after the position had gone the right way.

Because this bot gives the LLM a wider role, I care less about a single BUY or SELL call and more about the full plan: OPEN, HOLD, CLOSE, REVERSE, confidence, setup type, SL, TP, and the stated reason. Today, the realized result says the plan worked. I am still careful with that conclusion because there was no losing trade in the sample. A bot that never had to take a hit has not shown how it behaves under stress.

Still, among the four bots, this one gave the least messy result. It did not need a huge move, and it did not need rescue trades. It simply kept taking profit. That is rare enough that I do not want to dress it up too much.

MLScore GF-T4 GB

MLScore GF-T4 GB ended with -303 yen realized, plus an open GBPJPY short carrying -94 yen of floating loss. This bot had one +200 yen winner and two losses around -250 yen each. The payoff ratio was 0.80, which is not terrible by itself, but with a 1W / 2L record it was not enough.

The shape is simple and a bit frustrating. The winner was smaller than the combined damage, and the open position was not helping at the cut-off. The losses at -251 yen and -252 yen were almost identical, so this looks more like a fixed-risk structure than a chaotic failure. That can be improved, but only if the entry filter or exit timing earns enough winners to justify the stop size.

My guess is that the issue is not only signal quality. The exit width may be too neat for the market it is facing. I am not fully sure yet, but the open short at the end made the day feel unfinished.

BoundSniper

BoundSniper is the most useful warning today. It closed three winners and one loser, yet still ended at -186 yen. The reason is blunt: the losing trade was -414 yen, while the three winners added only +228 yen together. When I saw that -414 yen cut, the first reaction was not dramatic; it was more like, “again, this shape.”

This bot is not trying to predict the market by itself. It carries TradingView signals into MT5, so the key question is whether the execution and exit handling preserve the edge of the original strategy. Today, they did not. The winning trades were too small to pay for the one large loss.

BoundSniper does not need a philosophical rewrite from this one day. It needs a sharper answer to one practical question: when a USDJPY move goes wrong, how long should the position be allowed to stay wrong? Until that is cleaner, even a good-looking sequence of trades can remain fragile.

Summary

The day ended positive, but the important lesson came from the red side of the ledger. LLMBridgeTrader was clean, GateGrid AI survived through basket behavior, MLScore needs a better balance between stop size and signal quality, and BoundSniper showed how one exit can outweigh several correct calls.

I am keeping the focus on maximum loss and payoff ratio for the next run. Profit is nice, but the bot that teaches the most is often the one that makes the account feel slightly uncomfortable.

Four MT5 bot trade log for June 30, 2026

The strange part of today was not that the portfolio lost money. The strange part was that one bot won 14 out of 15 closed trades and the four-bot total still finished at -974 yen. I had to look at that twice, because a 93.3% win rate usually feels like the kind of number you want to keep. Today it was only enough to keep GateGrid AI green, not enough to save the whole board.

The real theme was not entry accuracy. It was payoff ratio and max loss. Across all four bots, the average win was about 68 yen while the average loss was about 255 yen. That gap is not dramatic on one trade, but after 33 closed trades it starts to explain the day better than the win rate does.

Bot-by-bot results

■ GateGrid AI +442 yenPair: GBPUSD-Record: 14W / 1LWin rate: 93.3%Gross profit: +775 yenGross loss: -333 yenPayoff ratio: 0.17Max loss: -333 yen

■ BoundSniper Bot -755 yenPair: USDJPY-Record: 5W / 3LWin rate: 62.5%Gross profit: +436 yenGross loss: -1,191 yenPayoff ratio: 0.22Max loss: -771 yen

■ LLMBridgeTrader -410 yenPair: EURUSD-Record: 4W / 5LWin rate: 44.4%Gross profit: +360 yenGross loss: -770 yenPayoff ratio: 0.58Max loss: -206 yen

■ MLScore GF-T4 GB -251 yenPair: GBPJPY-Record: 0W / 1LWin rate: 0.0%Gross profit: +0 yenGross loss: -251 yenPayoff ratio: 0.00Max loss: -251 yen

■ Total -974 yenPairs: GBPUSD- / USDJPY- / EURUSD- / GBPJPY-Record: 23W / 10LWin rate: 69.7%Gross profit: +1,571 yenGross loss: -2,545 yenPayoff ratio: 0.27Max loss: -771 yen

Today’s theme

Today was a clean reminder that a bot can be right often and still be fragile. GateGrid AI did the best job on the surface. It kept taking small GBPUSD wins, and most of those exits looked like the kind of grind a grid-style system is built for. But the payoff ratio was only 0.17, so the single -333 yen loss mattered a lot more than the win count made it feel. Seeing +775 yen of gross profit get cut down that quickly made me pause a little.

BoundSniper Bot had a different problem. It won more than it lost by count, but the first closed loss came in at -771 yen including swap. That one number bent the entire day. Since BoundSniper is mainly the execution bridge for TradingView signals rather than a prediction engine, I do not read this as an MT5 delivery issue. The problem sits closer to the signal and exit design.

LLMBridgeTrader was more interesting from the LLM experiment side. The losses were not huge individually, and the payoff ratio of 0.58 was the best among the losing bots. Still, it lost five of nine closed trades. When a bot is allowed to decide OPEN, HOLD, CLOSE, or REVERSE, the exit is not a small detail. It is the experiment.

GateGrid AI

GateGrid AI was the only clear winner today, finishing at +442 yen on GBPUSD-. Fourteen wins and one loss is a strong result, but I do not want to over-celebrate it. The average win was about 55 yen, while the only loss was -333 yen. That means one bad exit was roughly six average wins.

The design did what it is supposed to do in one sense. It kept finding small harvests and avoided ending red. CatBoost and the local LLM filter are meant to reduce bad entries, and today the entry side looked decent. But the exit side still carries the risk. If the bot keeps a losing grid alive too long, the day can flip quickly.

The uncomfortable lesson is that GateGrid AI may need to stay extremely selective. A win rate around 70% would not be enough with this payoff structure. Even 80% could be shaky. Today it survived because 93.3% is a very high bar, and that is not something I want to depend on every session.

BoundSniper Bot

BoundSniper Bot finished at -755 yen realized, with a separate open USDJPY short showing -90 yen floating loss at the report close. The closed-trade win rate was 62.5%, which sounds acceptable until the loss distribution shows up. The max loss was -771 yen, and another loss came in at -416 yen. The small wins, from +30 to +256 yen, could not repair that.

This bot does not think through the market by itself. It receives TradingView signals and sends them to MT5. So when it loses this way, I look less at the transport layer and more at whether the TradingView-side exit is late, too wide, or too tolerant of reversal.

The -771 yen loss is the number that bothered me most today. Not because it is huge in absolute terms, but because it tells me the bot can let one trade become the whole story. That is the part I would want to isolate before adjusting anything cosmetic.

LLMBridgeTrader

LLMBridgeTrader ended at -410 yen on EURUSD-. The bot had four wins and five losses, so it was not completely off, but it never found enough clean follow-through. The best thing in the data is that its max loss was -206 yen, much smaller than BoundSniper’s worst loss. The worse part is that it kept leaking.

For an LLM-driven bot, I care less about whether one entry was clever and more about whether the model knows when to stop believing its first plan. Today, the exit decisions look mixed. Some losses were cut in a controlled range, but the sequence still says the bot was too willing to re-engage or stay wrong.

The payoff ratio of 0.58 is not terrible compared with the other bots, but with a 44.4% win rate it was not enough. It needs either cleaner filtering before entry or better switching behavior after the position starts moving against the thesis. My guess is that the exit prompt and the HOLD-to-CLOSE threshold are more important than adding another indicator.

MLScore GF-T4 GB

MLScore GF-T4 GB had only one closed trade, a GBPJPY loss of -251 yen. That is too little data to judge the model. One stop-out can be noise, and I do not want to build a whole story around a single trade.

Still, the clean loss is useful as a record. It did not snowball, and it did not stack positions. On a day where max loss shaped the portfolio, a single controlled loss is not the worst thing a bot can do.

The next check is whether this bot tends to produce isolated losses or whether it clusters them. Today only tells me that the first attempt failed. I need more samples before I trust any conclusion.

Wrap-up

The total came in at -974 yen realized, even with a 69.7% combined win rate. That is the kind of day that makes the dashboard feel misleading if I only look at green and red trade counts. The bots were not all broken. The problem was that the losing trades were much heavier than the winning trades.

For tomorrow, I would not start with the entries. I would start with the exits: BoundSniper’s worst-loss rule, LLMBridgeTrader’s CLOSE judgment, and GateGrid AI’s point of giving up on a grid. The trade log is saying one thing pretty clearly today: the bots can find wins, but the exits still decide whether those wins survive.

Conclusion

GateGrid 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 yen

Today’s Theme

The 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 Analysis

GateGrid 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-Up

The 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.

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 referenced

Today’s Theme: The Trap Was Not Low Accuracy

The 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 Line

GateGrid 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 Fixed

MLScore 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 Control

LLMBridgeTrader 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.

Summary

The 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.

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 yen

Open 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 theme

Today 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 AI

GateGrid 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.

BoundSniper

BoundSniper 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.

LLMBridgeTrader

LLMBridgeTrader 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 GB

MLScore 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.

Summary

Today’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 Note

The 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?”

Conclusion

The 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 yen

Record: 5W / 2L

Win rate: 71.4%

Gross profit: +235 yen

Gross loss: -747 yen

Payoff ratio: 0.13

Max loss: -728 yen

■ BoundSniper -25 yen

Record: 2W / 1L

Win rate: 66.7%

Gross profit: +52 yen

Gross loss: -77 yen

Payoff ratio: 0.34

Max loss: -77 yen

■ LLMBridgeTrader -175 yen

Record: 1W / 3L

Win rate: 25.0%

Gross profit: +162 yen

Gross loss: -337 yen

Payoff ratio: 1.44

Max loss: -201 yen

■ MLScore GF-T4 GB -468 yen

Record: 1W / 1L

Win rate: 50.0%

Gross profit: +144 yen

Gross loss: -612 yen

Payoff ratio: 0.24

Max loss: -612 yen

■ Total -1,180 yen

Record: 9W / 7L

Win rate: 56.3%

Gross profit: +593 yen

Gross loss: -1,773 yen

Payoff ratio: 0.26

Max loss: -728 yen

Today’s theme

The 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 AI

GateGrid 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.

BoundSniper

BoundSniper 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.

LLMBridgeTrader

LLMBridgeTrader 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 GB

MLScore 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.

Summary

Today 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

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 yen

Today’s Theme: Loss Size Beat Win Rate

The 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 Read

BoundSniper 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-Up

Today 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.

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 yen

Today’s theme: the exit mattered more than the entry

The 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 wound

GateGrid 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 judge

MLScore 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 small

LLMBridgeTrader 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 not

BoundSniper 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.”

Summary

The 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.

Win Rate Lied This Week: The Rule-Based Bot Survived While the LLM Bots Bled

MT5 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 results

Trade-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 yen

Today’s theme: exits beat win rate

The 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 AI

GateGrid 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.

BoundSniper

BoundSniper 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.

LLMBridgeTrader

LLMBridgeTrader 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-T4

MLScore 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.

Summary

The 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.

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 yen

Today’s theme: the win rate looked fine, the payoff ratio did not

The 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 up

GateGrid 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 <= 0; keep monitoring.” As a basket rule, that makes sense. Price touched the target area, but the whole basket was not profitable yet. Still, this kind of rule can also keep exposure open longer than expected. GateGrid AI made money today, but the small-win structure means the exit design has to stay tight.

BoundSniper: simple execution, clean result

BoundSniper 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 shape

LLMBridgeTrader 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 portfolio

MLScore 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.

Summary

Day 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.