![The Power of Diversification: Why You Need Multiple Bots [June 1st Test]](https://is1-ssl.mzstatic.com/image/thumb/Podcasts211/v4/4d/5c/9a/4d5c9ac8-5654-b1b9-d3c8-844b86339abc/mza_4503003116816446549.jpg/250x250bb.jpg)
Afleveringen
-
Conclusion
The five-bot portfolio finished July 17 at -1,362 yen realized, with another -175 yen unrealized on an open ML_ScoreAnalyst position. The combined mark-to-market result was therefore -1,537 yen.
The loss itself is not the most useful part of the record. Exit structure separated the bots far more clearly than entry style did. MAribbonTrader won only one of two trades, yet ended positive because its average winner was 1.74 times its average loser. GateGrid AI, LLMBridgeTrader, and ML_ScoreAnalyst produced seven losing closes between them without a single winner to absorb the damage.
The -602 yen stop on ML_ScoreAnalyst made me pause. It was not an unusual malfunction; it appears to be the intended fixed-stop design doing exactly what it was told to do. That may be more uncomfortable than a software error, because it points back to the payoff geometry itself.
Bot-by-Bot Results
■ GateGrid AI -393 yenRecord: 0W / 3L (Win rate 0.0%)Gross profit: 0 yenGross loss: -393 yenPayoff ratio: Not availableMax loss: -252 yen
■ BoundSniper Bot +10 yenRecord: 1W / 0L (Win rate 100.0%)Gross profit: +10 yenGross loss: 0 yenPayoff ratio: Not availableMax loss: 0 yen
■ LLMBridgeTrader -479 yenRecord: 0W / 2L (Win rate 0.0%)Gross profit: 0 yenGross loss: -485 yenSwap: +6 yenPayoff ratio: Not availableMax loss: -290 yen
■ ML_ScoreAnalyst -602 yen realizedRecord: 0W / 1L (Win rate 0.0%)Gross profit: 0 yenGross loss: -602 yenPayoff ratio: Not availableMax loss: -602 yenOpen P/L: -175 yen
■ MAribbonTrader +102 yenRecord: 1W / 1L (Win rate 50.0%)Gross profit: +240 yenGross loss: -138 yenPayoff ratio: 1.74Max loss: -138 yen
■ Total -1,362 yen realizedRecord: 2W / 7L (Win rate 22.2%)Gross profit: +250 yenGross loss: -1,618 yenSwap: +6 yenPayoff ratio: 0.54Max loss: -602 yenOpen P/L: -175 yenResult including open P/L: -1,537 yen
Today’s Theme: An Entry Filter Cannot Rescue a Weak Exit
These five bots do not make decisions in the same way. BoundSniper relays TradingView instructions. ML_ScoreAnalyst scores a setup with CatBoost. GateGrid AI adds several entry gates before allowing a trade. LLMBridgeTrader lets an LLM choose OPEN, HOLD, CLOSE, or REVERSE. MAribbonTrader asks a local model to read chart structure and then trades around that interpretation.
Despite those differences, the day converged on one issue: what happened after entry.
A bot can reject mediocre setups, score a breakout correctly, or produce a persuasive market explanation. None of that guarantees a durable result if the position is held until a distant fixed stop, if reversal handling creates overlapping exposure, or if the model does not abandon its original thesis soon enough.
The useful experiment is no longer just “Did the model pick the right direction?” It is “What information was available when the trade should have been closed, and what did the bot decide to do with it?”
GateGrid AI: Multiple Gates, but the Exit Sequence Still Hurt
GateGrid AI closed three losing GBPUSD trades for -393 yen. The first short was opened at 1.34598 and covered at 1.34753 for -252 yen. That was the largest loss inside this bot.
The later sequence deserves more attention. A buy was filled at 1.34762, then a sell was filled at 1.34681. Both sides were closed at 10:17, producing losses of -130 yen and -11 yen. The record shows simultaneous opposing exposure and an immediate flattening sequence. That looks less like a simple bad directional call and more like a coordination problem around reversal, hedging, or grid shutdown.
GateGrid’s CatBoost and Ollama layers are designed to be selective before entry. On this day, the missing evidence is what happened after those gates opened. The next log review should align the model score, Ollama response, active grid state, close trigger, and any reversal flag on the same timeline. Without that, tuning the entry threshold would be guesswork.
BoundSniper Bot: The Bridge Worked, but One Tiny Win Proves Little
BoundSniper opened a USDJPY short at 162.255 and closed it 45 seconds later at 162.245 for +10 yen. The trade was clean, fast, and profitable.
That is encouraging from an execution perspective. The TradingView instruction reached MT5, the position was opened, and the exit was transmitted without a visible operational failure. Since BoundSniper does not create the market thesis itself, this is exactly the part of the system it needs to perform well.
Still, a 100% win rate from one trade is mostly decoration. There was no losing trade, so the payoff ratio cannot be calculated. The result says the bridge functioned; it does not yet say the upstream TradingView strategy has an edge.
LLMBridgeTrader: The LLM Had Control of the Exit, but the Hard Stop Did the Work
LLMBridgeTrader finished at -479 yen after swap. One position closed for -290 yen, while a later EURUSD short lost -195 yen.
The second trade is the cleaner test because both entry and exit appear in the day’s report. The bot sold at 1.14275 at 14:00 and exited at 1.14395 at 17:17. The position remained open for more than three hours and eventually closed at the stop level.
This bot is allowed to return HOLD, CLOSE, or REVERSE. That makes the exit path the central part of the experiment. Yet the live result looks no more adaptive than a trade held until a mechanical stop. I cannot say the LLM ignored an obvious exit without seeing its decision logs, but the record gives no sign that its broader authority improved the outcome.
For the next review, every HOLD decision should be stored with current unrealized P/L, recent price structure, confidence, and the reason the model rejected CLOSE. The most valuable training examples may be the moments when the model kept defending a position that later stopped out.
ML_ScoreAnalyst: The Model Score Is Only Half the Bet
ML_ScoreAnalyst bought GBPJPY at 218.605 and was stopped at 218.003 for -602 yen. It then opened a new short that remained active at the end of the report with -175 yen unrealized.
The closed loss is consistent with the bot’s roughly 60-pip stop setting. The profit target is around 25 pips. That structure needs a win rate of about 70.6% before trading costs just to break even. A scoring model can be directionally useful and still struggle under that burden.
This is why the -602 yen loss matters beyond one bad trade. It is the natural consequence of a design where one full stop requires more than two normal target wins to repair. Raising the CatBoost threshold may reduce weak entries, but threshold tuning alone will not fix an unfavorable payoff profile.
The open short also matters. Realized performance was -602 yen, but actual end-of-day exposure made the bot’s contribution -777 yen on a mark-to-market basis. The next test should compare the existing 60/25 structure with volatility-adjusted exits and a less asymmetric fixed alternative.
MAribbonTrader: A 50% Win Rate Was Enough
MAribbonTrader was the most balanced result of the day. Its first GBPCAD short earned +240 yen. Its second short lost -138 yen. The final result was +102 yen with a 50% win rate and a payoff ratio of 1.74.
That is the cleanest exit profile in the group. The winner was allowed to reach its target, while the loser remained smaller than the prior gain. The second loss included some slippage around the stop, but it did not erase the first trade.
Two trades are not enough to validate chart-reading intelligence. The model may have read the MAribbon context well, or it may simply have landed on a favorable pair of trades. What can be said from the execution record is narrower and more useful: the exit geometry gave the bot room to survive an ordinary loss.
For this bot, the next layer of analysis should connect each result to the image prompt, the detected ribbon state, the model’s WAIT or entry rationale, and the reason for exit. The positive result is welcome, but the reusable evidence lives in those logs.
Summary
The portfolio’s 22.2% win rate was weak, but the deeper issue was the total payoff ratio of 0.54. Gross profits reached only +250 yen against -1,618 yen in gross losses. A system cannot filter its way out of that imbalance forever.
The next improvement should be built around exit snapshots rather than another round of entry optimization. For every open position, the bots need a record of maximum favorable excursion, maximum adverse excursion, model confidence, exit recommendation, and the reason a close was postponed. That would show whether losses came from poor entries, slow recognition, rigid stops, or confused reversal handling.
Bots reveal their real character after they are already in the market. July 17 made that part unusually visible.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
Looking back at the operating logs of the AI trading bots on July 15 and 16, a clear and somewhat painful theme has emerged. It is the reality that “the timing of the exit (closing a position) is far more important than the frequency or accuracy of the entry.”
The Illusion of Win Rate and the Payoff Ratio (Lessons from July 15)
On July 15, we ran four MT5 bots, ending the day with a total loss of -1,456 JPY.
Some bots recorded a 50% win rate that day, yet the account balance still decreased. Overall, the record was 6 wins and 8 losses (a 42.9% win rate), meaning they were not losing excessively. The bots were not wildly misjudging the market direction all day.
The problem was that they were “paying too much when they were wrong.” The payoff ratio was only 0.51, meaning the average profit was only half the size of the average loss. Even if small profits are accumulated, a single loss, inflated by a delayed exit, can wipe them all out. Faced with such results, the “win rate” metric feels like mere noise.
AI’s Struggle and the Victory of Simplicity (Lessons from July 16)
On the following day, July 16, we ran five bots, including the newly added MAribbonTrader. The realized profit and loss was -464 JPY.
On this day, the difference in the bots’ “approaches” clearly divided the results. The most outstanding performer was, ironically, the least “conversational” bot, ML_ScoreAnalyst. Without hesitation, this system successfully hit the take-profit on both of its two trades, generating a profit of +502 JPY on its own.
In contrast, the bots that relied on LLMs (Large Language Models) or image recognition AI for judgment struggled with “cutting losses,” “switching positions,” and “staying out of the market.” The decision of whether to “HOLD” or “CLOSE” a position after entering proved to be the most costly challenge.
Behavior and Challenges of Each Bot
Over these two days, the different risks associated with each of the five bots became apparent.
* GateGrid AI
On the 15th, despite a 50% win rate, delayed exits made the trades too costly, resulting in a loss. On the 16th, it showed inexplicable behavior, closing a trade in the same second it was opened, resulting in a -13 JPY loss. While the entry filter is functioning, a detailed log review of the handoff between execution and closing is necessary.
* BoundSniper Bot
This is a rule-based bot that executes signals received from TradingView. It had a 50% win rate on the 15th, but on the 16th, it suffered seven consecutive losses after one win, dropping its win rate to 12.5%. The issue is not the execution engine itself; improving the quality of the upstream signals and revising the exit rules during losing streaks is urgently needed.
* LLMBridgeTrader
On the 15th, despite a 33.3% win rate, it limited its losses and showed a decent structure with a payoff ratio of 1.23. However, on the 16th, immediately after a loss, it quickly took a position in the opposite direction and held an unrealized loss (-145 JPY). Measures are needed to prevent delayed withdrawals and overreaction (chasing) after a loss.
* ML_ScoreAnalyst (formerly MLScore GF-T4)
On the 16th, it successfully took profit on two GBPJPY long trades, achieving a commendable result of +502 JPY. However, on the 15th, it had a record of “a winning trade of +300 JPY and a losing trade of -599 JPY,” revealing the issue of its stop-loss being too wide. We must continue to evaluate the “true cost” of this wide stop-loss, rather than just trusting clean wins like those on the 16th.
* MAribbonTrader
This bot, which uses image recognition AI to read charts, held a position for over 12 hours on the 16th, resulting in the largest single loss of the day (-447 JPY). The market context must have changed during that long holding period, making it necessary to verify whether the exit mechanism is functioning properly.
Next Steps: Towards Exit Discipline
In live automated trading, what protects the day’s profits is the decision that “I will not hold this position any longer.” The results of these tests teach us that future system improvements should focus on “exit discipline” rather than “entry confidence.”
In the next iteration, we will implement the following changes:
* Detailed State Logging: Record the position direction, unrealized P/L, model confidence, and the reason for the decision (e.g., HOLD or CLOSE) as a compact log to make the validity of the closing decision verifiable.
* Review Maximum Holding Time: Set re-evaluation triggers based on elapsed time to reduce the risks associated with holding positions for a long time.
* Introduce Cooldowns: Prevent immediate entries right after a loss is finalized, separating genuine trend reversals from “emotional chasing.”
Systems equipped with advanced AI models have, ironically, left us with the most human and difficult question of “when to exit.” However, these clear differences between the systems and the records of their failures are precisely the most valuable data we need to push them to the next level.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
Zijn er afleveringen die ontbreken?
-
Conclusion
Closed trades finished at +1,103 yen across the four bots. That sounds clean at first glance, and part of me wanted to leave it there. But BoundSniper carried an open floating loss of -641 yen, which pulled the effective result down to +462 yen. I paused at that number, not because it was disastrous, but because it reminded me how easily a good-looking day can become an exit problem.
The entries were not the main story today. GateGrid AI and MLScore GF-T4 GB did their job, LLMBridgeTrader struggled, and BoundSniper did not close at all. The lesson is uncomfortable but useful: when an LLM or an automated system is allowed to decide whether to keep holding, the exit logic deserves as much attention as the entry signal.
Bot-by-bot results
■ GateGrid AI +852 yenRecord: 11W / 1LWin rate: 91.7%Gross profit: +1,006 yenGross loss: -154 yenPayoff ratio: 0.59Max loss: -154 yenFloating P/L: 0 yen
■ BoundSniper 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: N/AFloating P/L: -641 yen
■ LLMBridgeTrader -266 yenRecord: 2W / 3LWin rate: 40.0%Gross profit: +116 yenGross loss: -382 yenPayoff ratio: 0.46Max loss: -196 yenFloating P/L: 0 yen
■ MLScore GF-T4 GB +517 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +517 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/AFloating P/L: 0 yen
■ Total +1,103 yen realizedRecord: 15W / 4LWin rate: 78.9%Gross profit: +1,639 yenGross loss: -536 yenPayoff ratio: 0.82Max closed loss: -196 yenFloating P/L: -641 yenEffective P/L: +462 yen
Today’s theme
Today was a reminder that win rate can flatter the system. The total win rate was 78.9%, which looks strong, and GateGrid AI alone printed 11 wins from 12 exits. Still, the combined payoff ratio was only 0.82, so the average win was smaller than the average loss. That is not a fatal structure for a high-win-rate system, but it leaves less room for a single awkward hold.
The bigger issue was the open position. BoundSniper had no closed result, so it looked harmless in realized P/L, yet its -641 yen floating loss was larger than every closed loss of the day. That is the part that made me stop and look twice. The damage was not booked, but it was already sitting there.
GateGrid AI
GateGrid AI was the strongest closed-trade performer today. It ended at +852 yen, with 11 wins and 1 loss, and the largest win was +424 yen. That single +424 yen trade helped cover a lot of smaller exits, and honestly it made the log feel safer than it really was for a moment.
The weak point is the payoff ratio. At 0.59, the average win was still smaller than the average loss. GateGrid AI can survive that when the CatBoost gate, Ollama filter, ATR checks, session thresholds, and trailing management keep the win rate high. But if the entry filter loosens or the market starts chopping harder, that ratio can become a quiet problem.
As an LLM/ML hybrid, GateGrid’s best behavior today was not just entering. It also exited without letting the one loss grow beyond -154 yen. That matters. For a grid-style bot, the real test is whether the model can stop building exposure when the setup gets stale, and today it mostly did.
BoundSniper
BoundSniper closed nothing today. On paper, the realized result is 0 yen, but the open EURUSD position was sitting at -641 yen by the report time. This is the number that changed the whole reading of the day. A flat realized result is not neutral when the position is still bleeding.
BoundSniper is mainly an execution bridge for TradingView signals rather than a bot that predicts the market itself. That means the quality of the day depends heavily on whether the external signal provides a timely exit, and today the exit had not arrived by the cutoff. Maybe the strategy is built to hold through this kind of drawdown. I do not know that from this report alone, so I do not want to overstate it. Still, for live operation, the open-loss rule needs to be treated as part of the system’s score, not as an afterthought.
LLMBridgeTrader
LLMBridgeTrader had the most interesting failure pattern. It won twice, then gave back more than it earned through three losses. The final result was -266 yen, and the payoff ratio was 0.46. When I saw the -196 yen stop loss, I had the familiar reaction: this is probably not an entry-only issue.
This bot gives the AI more responsibility. It can decide BUY, SELL, NONE, and also OPEN, HOLD, CLOSE, REVERSE, or NONE. That makes the exit decision central. Today, the losing trades suggest the model either held too long, changed its view too late, or accepted setups where the expected reward was too thin. I cannot prove the exact reason without the prompt log, but the shape points toward exit judgment and risk-reward filtering more than raw direction alone.
The good side is that the losses were not uncontrolled. The max closed loss was -196 yen, not a runaway event. But the two wins were only +45 yen and +71 yen, so the bot needs either cleaner exit timing or a stricter rule that blocks trades when the likely reward is too small.
MLScore GF-T4 GB
MLScore GF-T4 GB did exactly what a small automated system needs to do on a quiet report: it took two closed wins and finished at +517 yen, including +13 yen swap. Both exits hit TP-style comments, and there were no open positions left at the cutoff.
There is not enough detail in the report to make a deep claim about the model behind MLScore. I will keep this modest. The result was clean, the exits were clean, and unlike BoundSniper, it did not leave a floating problem behind. Some days that is enough.
Wrap-up
The day was profitable, but not as comfortable as the closed P/L suggested. GateGrid AI and MLScore carried the board, LLMBridgeTrader exposed the cost of weak payoff structure, and BoundSniper reminded me that unrealized risk is still risk. The next thing I would check is not just which bot entered well, but which bot knew when the trade had stopped being worth holding.
② Substack Note
Four MT5 bots finished July 14 with +1,103 yen in closed P/L, but the cleaner headline hides the real lesson.
GateGrid AI and MLScore did the lifting. LLMBridgeTrader struggled with payoff. BoundSniper carried a -641 yen open loss, which made the effective result much smaller.
Today was less about entry accuracy and more about exits. The trade that is not closed yet can still become the main story.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
You can identify a reversal early and still lose the trade.
Price makes a new high.
Momentum fails to confirm it.
The divergence looks clear.
You sell.
Price continues higher.
You are stopped out.
Another divergence appears.
You sell again.
The market keeps moving in the same direction.
Eventually, the reversal may happen.
But by then, your capital and patience may already be damaged.
The warning was not necessarily wrong.
You simply treated it as if the event had already happened.
Weakening is not the same as reversing
When price continues higher while momentum becomes weaker, something has changed inside the move.
The trend may be losing energy.
But losing energy does not mean the trend has ended.
A car can slow down without stopping.
It can stop without reversing.
Momentum indicators can reveal that the current move is no longer as strong as it was.
They cannot guarantee when price will turn.
As long as buyers remain in control, price can continue making new highs even while momentum declines.
Divergence identifies tension.
It does not resolve it.
The earlier the entry, the longer the fight
Calling a top or bottom early is attractive.
The potential reward is larger.
The entry looks impressive after the reversal happens.
But an early countertrend position must survive the part of the move that has not finished.
Selling an active uptrend means holding while buyers are still in control.
Buying an active downtrend means standing in front of sellers who have not stopped.
Even if the final direction is correct, the trade can fail before the market proves it.
Being early is not always different from being wrong from the account’s point of view.
Let the warning change what you watch
A divergence does not have to trigger an order.
It can move the market into a higher-alert state.
After bearish divergence in an uptrend, you might wait for:
A break below a recent swing low.
Failure to make another higher high.
A clear break of trend structure.
A weak recovery after the first decline.
A candle close that confirms selling pressure.
The exact trigger depends on the strategy and timeframe.
The sequence matters more than the specific tool.
Momentum identifies the warning.
Price confirms the change.
Risk determines whether the trade is worth taking.
Confirmation has a cost
Waiting for confirmation means giving up part of the move.
You will not sell the exact top.
You will not buy the exact bottom.
The entry may offer a smaller reward relative to the stop.
That can feel inefficient.
But early entry has costs too.
Multiple stop-outs.
Long periods of holding against the trend.
The temptation to increase size because the reversal feels overdue.
The mental strain of defending a prediction price has not confirmed.
The choice is not between a perfect early entry and a late entry.
It is between paying for confirmation with some lost distance, or paying for anticipation through additional uncertainty and failed attempts.
Separate alerts from orders
This distinction becomes especially useful in automated trading.
A simple bot often turns every detected condition into an order.
RSI reaches a threshold.
Moving averages cross.
Divergence appears.
Buy or sell.
The code is clean.
The logic may be too compressed.
In an MT5 bot, I would treat divergence as an alert layer.
Then I would require separate confirmation from price structure.
I would also check spread, trading session, and major-event restrictions before allowing an order.
This creates more conditions and fewer trades.
It also prevents one indicator from carrying responsibility it was never designed to handle.
Detection and execution should be separate layers.
Give every signal one job
When a strategy struggles, traders often add more indicators.
RSI.
MACD.
Moving averages.
Volume.
Volatility filters.
More information does not always create clearer decisions.
It helps to assign each input a specific role.
One tool identifies the market environment.
Another detects weakening momentum.
Another confirms entry.
Another adjusts position size.
Another stops the system.
For example:
The higher timeframe defines the trend.
Divergence creates an alert.
A swing break confirms the change.
Spread and session rules permit execution.
A drawdown limit stops trading.
Not every indicator needs to answer buy or sell.
Some signals are more useful when they only tell you what to watch next.
A warning can still protect an open position
Not trading divergence does not mean ignoring it.
A warning can change how you manage existing risk.
You may avoid adding a new position.
Take partial profit.
Reduce size.
Tighten operational oversight.
Stop giving the trend unlimited benefit of the doubt.
Divergence may be unreliable as a standalone entry.
It can still be valuable as a reason to become more cautious.
Between noticing and acting
Markets reward awareness.
Seeing a change before it becomes obvious can be useful.
But observation and execution are different skills.
Something looks weaker.
The move feels different.
Momentum no longer supports price.
That is the beginning of analysis, not the end.
The next question is whether price has confirmed the change.
Does your signal tell you that something may happen?
Or does it tell you that it already has?
Before turning a warning into a position, make sure you know which job the signal is doing.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
From July 6 to July 10, 2026, I continued running four MT5 automated trading bots in parallel.
The four systems were:
* GateGrid AI
* BoundSniper Bot
* LLMBridgeTrader
* MLScore GF-T4 GB
The combined realized result for the week was -3,060 yen.
On paper, it was simply a losing week.
But when I reviewed the logs, the total loss itself was not what stood out most.
The bots did not struggle to win trades.
In fact, there were several days when the number of winning trades looked fairly strong.
And yet, the account still lost money.
That gap appeared again and again throughout the week.
The real issue was not how often the bots won.
It was how much they gave back when they lost.
July 6: A difficult start to the week
The result for July 6 was -1,976 yen.
The combined record was 1 win and 10 losses.
It was the worst day of the week.
LLMBridgeTrader recorded the only winning trade, while GateGrid AI lost 733 yen and MLScore lost 621 yen.
The directional calls were not good, but the larger problem was how long some losing positions remained open.
Instead of exiting when the trade idea began to fail, the bots often waited until the loss had already grown.
The weakness in the exit logic was visible from the very first day.
July 7: Thirteen wins, but only 276 yen in profit
The result for July 7 was +276 yen.
The combined record was 13 wins and 3 losses.
At first glance, that looks like an excellent day.
However, the payoff ratio was only 0.31.
There were very few losing trades, but each loss was much larger than each win.
As a result, 13 winning trades produced only a small net profit.
GateGrid AI is the clearest example.
It won 8 of its 11 trades.
Even so, it finished the day at -230 yen.
Eight small wins were erased by three larger losses.
Looking only at the win count, I might have concluded that the bot was performing well.
In reality, the structure was fragile.
As long as the bot kept collecting small gains, the weakness remained hidden.
Once a deeper loss appeared, most of the previous profits disappeared.
July 8: More wins than losses, but still negative
The result for July 8 was -620 yen.
The combined record was 9 wins and 7 losses.
Again, the number of winning trades was higher than the number of losing trades.
But the day still ended in the red.
The biggest factor was a single -418 yen loss from BoundSniper.
Small profits from the other trades could not absorb one large loss.
This was another reminder that win count alone says very little about the actual health of a trading system.
July 9: One loss erased everything
The result for July 9 was -481 yen.
There were only three trades in total, with 2 wins and 1 loss.
It was a quiet day.
However, the single losing trade came from GateGrid AI and cost 542 yen.
That one loss erased all the small profits produced by the other bots.
Two out of three trades were correct.
The day still ended negative.
This shows why improving directional accuracy alone is not enough.
The more important question is how cheaply the system can exit when it is wrong.
July 10: MLScore performed well, but the portfolio still fell short
The result for July 10 was -259 yen.
The combined record was 12 wins and 8 losses.
MLScore GF-T4 GB closed two short positions at take profit and earned +483 yen.
For this bot, it was one of the cleanest results of the week.
However, the gains were not enough to cover the losses from the other systems.
MLScore performed well on its own, but when four bots are running together, individual results are not the only thing that matters.
I also need to watch how losses overlap across the portfolio.
GateGrid AI: Winning often, but failing to keep the profit
GateGrid AI showed the clearest weakness this week.
On July 7, it won 8 of 11 trades.
It still lost 230 yen.
Then, on July 9, a single trade produced a 542 yen loss.
The pattern is familiar.
The bot collects many small gains, then gives them back in one deeper loss.
The entry filters are not completely broken.
In fact, many trades still close in profit.
The problem begins after entry.
When the market changes and the original setup loses validity, the bot often remains in the position for too long.
Instead of making the entry logic even more complicated, the priority should be improving the conditions for early exit.
BoundSniper Bot: One large loss can outweigh several clean trades
BoundSniper Bot is a rule-based system that executes TradingView signals in MT5.
On July 7, it produced a clean +200 yen result.
On July 8, however, a single -418 yen stop loss pushed the day into negative territory, even though the bot won more trades than it lost.
The system is consistent because it follows clear rules.
But that strength can also become a weakness.
When the market changes after the signal appears, the bot may continue holding the original idea without reassessing whether the setup still makes sense.
The next step is not only to evaluate whether the initial signal was correct, but also whether the reasoning behind it remains valid after entry.
LLMBridgeTrader: Small gains, but four consecutive profitable days
The most interesting bot this week was LLMBridgeTrader.
It lost 232 yen on July 6.
After that, the daily results were:
* July 7: +76 yen
* July 8: +128 yen
* July 9: +57 yen
* July 10: +16 yen
The gains were not large.
Still, the bot remained profitable for four consecutive days.
Compared with the other systems, LLMBridgeTrader was better at avoiding prolonged exposure to bad positions.
It did not make money by holding one huge winner.
It made money by cutting weak ideas before they became expensive.
The result was modest, but its ability to preserve capital was the most stable among the four bots.
MLScore GF-T4 GB: A promising result on the final day
MLScore GF-T4 GB began the week with several losses, including the closing of older positions.
However, on July 10, two short positions reached their take-profit targets and produced +483 yen.
That gave a glimpse of the potential behind the machine-learning score.
The model may be useful for identifying trade direction.
Still, one good day is not enough to draw a conclusion.
I need more trades to determine whether high-score setups consistently produce better results.
I also need to review whether the current stop-loss and take-profit settings match the price behavior after entry.
The real problem was not the entry
When building an automated trading bot, it is easy to focus on entry accuracy.
Add another filter.
Use more training data.
Change the model.
Make the conditions more precise.
I have spent plenty of time improving entries.
But this week’s results suggest that the main weakness is no longer the entry alone.
On July 7, the bots recorded 13 wins and 3 losses.
On July 8, they recorded 9 wins and 7 losses.
On July 9, they recorded 2 wins and 1 loss.
None of those days looked terrible from a win-count perspective.
Yet the final weekly result was -3,060 yen.
That means the bots are not completely failing to predict direction.
The problem is structural.
The average gain is too small.
The average loss is too large.
Until that relationship changes, increasing the number of winning trades will not create stable profits.
Knowing when an idea has expired
Every trade begins with some kind of reasoning.
A trend may be developing.
A breakout may have occurred.
The AI may have produced a buy signal.
The machine-learning score may have been high.
But the original reason for entering may no longer be valid ten or thirty minutes later.
If the market changes and the bot continues holding based only on the original signal, the position becomes attached to outdated information.
The goal should not be to defend the original prediction.
The goal should be to exit cheaply when the original assumption is no longer supported.
A fixed stop loss may not be enough.
Time in the trade, fading momentum, acceleration in the opposite direction, conflict with a higher timeframe, and changes in volatility may all be useful exit signals.
The system needs a way to reassess the trade after entry.
Next week: Improving the exit rules
I do not plan to explain this week’s losses as a simple failure of entry accuracy.
The next improvements will focus on:
* Exiting before unrealized losses grow too large
* Reassessing whether the original setup is still valid after entry
* Handling positions that fail to move within a certain amount of time
* Separating situations where profits should be extended from situations where they should be secured early
* Adjusting the acceptable loss size for each bot
Losing trades are painful, but they are often the most honest source of information about a system.
This week was not only about failing to win.
It was about failing to keep the profits that had already been earned.
Before trying to increase the number of entries, I need to reduce the damage caused by each losing trade.
That will be the main focus of next week’s development and testing.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
I am currently running four MT5 automated trading bots (GateGrid AI, BoundSniper, LLMBridgeTrader, and MLScore GF-T4) simultaneously to verify their real-world behavior and performance.
I have compiled the operational results for July 9 and 10.
The harsh reality revealed by these two days of testing is that “no matter how high the win rate is, a single costly exit (stop loss) can destroy the portfolio.”
Even though the overall win rate exceeded 60% on both days, they both ended with negative balances. Through a detailed review, I will delve into the challenges facing the current system.
July 9 Analysis: The Day One Bad Exit Decided Everything
[Overall Performance]
* Total Trades: 3 (2 Wins, 1 Loss)
* Win Rate: 66.7%
* Realized Profit/Loss: -481 JPY (-496 JPY including MLScore’s unrealized loss)
A Fatal Blow from GateGrid AI
While BoundSniper (+4 JPY) and LLMBridgeTrader (+57 JPY) steadily accumulated small profits, GateGrid AI suffered a massive loss of -542 JPY in a single trade.
A Warning from a 0.06 Payoff Ratio
The total profit for the entire portfolio was a mere +61 JPY, whereas a single loss amounted to -542 JPY.
The 66.7% win rate is entirely meaningless here. This extreme payoff ratio (risk-reward ratio) serves as a strong warning to the system that the “retreat rules” are too slow when an idea turns out to be wrong.
July 10 Analysis: The Contrast Between Planned Take-Profits and Late Stop-Losses
[Overall Performance]
* Total Trades: 20 (12 Wins, 8 Losses)
* Win Rate: 60.0%
* Realized Profit/Loss: -259 JPY
Trading volume increased on this day, clearly highlighting the differences in the “quality of exits” among the bots.
Two Bots Shining with Great Exits
* MLScore GF-T4 GB
Successfully executed clean take-profits by precisely hitting pre-set targets (TP) twice, earning +483 JPY.
* LLMBridgeTrader
Despite having 1 win and 1 loss, it significantly extended its profits (+39 JPY) against its losses (-23 JPY), demonstrating a very healthy risk-reward payoff ratio of 1.70.
Two Bots Dragging Down the Portfolio with “Small Profits, Large Losses”
* GateGrid AI
Despite a winning record of 7 wins and 6 losses, it totaled -602 JPY. Extremely small profits, such as +8 JPY, stood out against large stop-losses, peaking at -289 JPY.
* BoundSniper
Suffered significant damage of -380 JPY on its first trade. Although it attempted to recover with two subsequent wins, it couldn’t fully pay off the initial debt and ended at -156 JPY.
Conclusion: What We Need Isn’t “New Predictions,” but “Rules to Accept Losses Cheaply”
The biggest lesson from these two days is that “planned exits beat frequent decisions.”
The AI models are already provided with sufficient market information, such as volatility, spreads, and the direction of higher timeframes, and their entry win rates are by no means bad.
However, in the current system (especially GateGrid AI), the decision to recognize that an entry idea has “died” and to retreat is made far too late.
The most crucial aspect of future system improvements is not giving the AI more information to increase entry accuracy.
“How to abandon a wrong idea as cheaply (with as shallow a wound) as possible”
Strictly enforcing this exit rule is the top priority for surviving in the market.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
The four-bot portfolio ended the day at -620 yen realized, with no open positions left at the report cutoff. The headline record was 9 wins and 7 losses, so the day was not simply a wipeout. That is what makes it a little more annoying. More wins than losses, yet still a red result.
The total gross profit was +961 yen, while gross loss reached -1,581 yen. The payoff ratio came out to 0.47, and that is the number I kept coming back to. BoundSniper had the largest single loss at -418 yen, GateGrid AI had two heavy cuts after one clean win, and LLMBridgeTrader was the only bot that finished positive. MLScore GF-T4 GB had no trades, which honestly may have been the quietest result on the sheet.
Bot-by-bot results
■ GateGrid AI -604 yenRecord: 1W / 2LWin rate: 33.3%Gross profit: +117 yenGross loss: -721 yenPayoff ratio: 0.32Max loss: -398 yen
■ BoundSniper Bot -144 yenRecord: 4W / 2LWin rate: 66.7%Gross profit: +278 yenGross loss: -422 yenPayoff ratio: 0.33Max loss: -418 yen
■ LLMBridgeTrader +128 yenRecord: 4W / 3LWin rate: 57.1%Gross profit: +566 yenGross loss: -438 yenPayoff ratio: 0.97Max loss: -195 yen
■ MLScore GF-T4 GB 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/ANote: No trades
■ Total -620 yen realizedRecord: 9W / 7LWin rate: 56.3%Gross profit: +961 yenGross loss: -1,581 yenPayoff ratio: 0.47Max loss: -418 yenFloating P/L: 0 yenEquity impact: -620 yen
Today’s theme: the win count looked fine, the loss size did not
Today was another reminder that a trading bot can be directionally useful and still lose money if the sizing of wins and losses is off. The portfolio won more often than it lost. That should give some room to breathe, but the losses were too heavy for the winners to cover.
The most awkward part was BoundSniper. It won 4 out of 6 trades and still finished at -144 yen because one USDJPY loss of -418 yen swallowed almost every small win around it. GateGrid AI had a simpler version of the same problem: one +117 yen win, followed by -323 yen and -398 yen. I saw that -398 yen and had the same reaction as the past few reports. The entry may not be the whole issue anymore.
GateGrid AI: one early win, then the basket broke
GateGrid AI had three closed GBPUSD trades. The first exit was +117 yen, which looked fine. Then the next two exits came in at -323 yen and -398 yen, leaving the bot at -604 yen for the day.
This bot is built as a multi-filter grid system. CatBoost judges entry probability, then Ollama checks context such as ATR, spread, higher-timeframe direction, session, and recent performance before the grid is allowed to form. That design is supposed to reduce weak participation, and I still like the idea. But the realized results are again pointing toward exit handling, not only entry filtering.
The two losing closes were much larger than the one win. The average win was 117 yen, while the average loss was 360.5 yen. A payoff ratio of 0.32 does not leave much room for error. If the grid is going to take small profits, it needs a sharper way to say the setup has failed before the loss reaches three times the normal winner.
BoundSniper Bot: good win rate, one loss did too much damage
BoundSniper Bot closed six USDJPY trades and won four of them. The winning trades were +128 yen, +50 yen, +42 yen, and +58 yen. The losses were -418 yen and -4 yen. The result was -144 yen.
This one stung in a different way. A 66.7% win rate should not automatically end red, but the largest loss was almost exactly the size of the four winners combined. That -418 yen trade did the damage. The final -4 yen loss was basically noise; the day was decided by the bigger miss.
BoundSniper is a TradingView execution bridge rather than an AI decision system. It receives signals and sends them to MT5, so the key question is upstream exit design. The bridge worked. The trade logic it carried allowed one losing idea to sit too deep.
LLMBridgeTrader: the only positive bot, but still not clean
LLMBridgeTrader finished at +128 yen on EURUSD. It closed 7 trades, with 4 wins and 3 losses. The winners were +206 yen, +128 yen, +130 yen, and +102 yen. The losses were -115 yen, -128 yen, and -195 yen.
This was the best-shaped bot of the day, even though it was not flawless. The payoff ratio was 0.97, which is close to balanced, and the win rate was 57.1%. Compared with GateGrid and BoundSniper, the losses were not wildly larger than the wins. The -195 yen loss was still noticeable, but it did not erase the whole day by itself.
Because this bot asks the LLM for OPEN, HOLD, CLOSE, REVERSE, confidence, setup type, and SL/TP ideas, I care less about whether it wins one trade and more about whether it can keep its decision cycle stable. Today, it did that better than the others. Not perfect, but less lopsided.
MLScore GF-T4 GB: no trades, no new information
MLScore GF-T4 GB had no trades today. That means no realized profit, no realized loss, and no floating position. There is not much to analyze from the daily report.
Still, “no trade” is not meaningless in a multi-bot setup. After several days where single large losses had a strong effect, sitting out can be a valid result. I cannot credit the bot for avoiding a specific bad setup without the signal log, but the account did not take damage from this lane today.
Closing thoughts
Today’s total loss was not huge, but the structure was familiar. More wins than losses, yet the day ended red. That is usually not a mystery. It means the system is paying too much when it is wrong.
LLMBridgeTrader was the only bot that produced a healthier balance between wins and losses. GateGrid AI and BoundSniper both showed the same uncomfortable pattern from different architectures: small wins, one or two outsized hits. The lesson is getting less subtle now. The next improvement is probably not “find more entries.” It is making the bad exits less expensive.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
Today was not a day where the numbers needed much interpretation. Across the four bots, the closed trades came out to 1 win and 10 losses, with realized P/L at -1,976 yen. MLScore GF-T4 GB also left one GBPJPY short open at -109 yen, so the equity impact was -2,085 yen. That is not a huge amount in absolute scale, but the shape of it was uncomfortable.
The only winning closed trade came from LLMBridgeTrader. Even there, the bot finished negative because the win was surrounded by six smaller losses. GateGrid AI and BoundSniper both had no winning exits at all, and MLScore started the day by realizing a large loss from a prior position. I do not want to dress this up too much. The day was mostly about failed exits, weak reversal timing, and trades that stayed wrong long enough to matter.
Bot-by-bot results
■ GateGrid AI -733 yenRecord: 0W / 2LWin rate: 0.0%Gross profit: 0 yenGross loss: -733 yenPayoff ratio: N/AMax loss: -403 yen
■ BoundSniper Bot -390 yenRecord: 0W / 1LWin rate: 0.0%Gross profit: 0 yenGross loss: -390 yenPayoff ratio: N/AMax loss: -390 yen
■ LLMBridgeTrader -232 yenRecord: 1W / 6LWin rate: 14.3%Gross profit: +130 yenGross loss: -362 yenPayoff ratio: 2.15Max loss: -80 yen
■ MLScore GF-T4 GB -621 yenRecord: 0W / 1LWin rate: 0.0%Gross profit: 0 yenGross loss: -621 yenPayoff ratio: N/AMax loss: -621 yenOpen position: -109 yen floating P/L
■ Total -1,976 yen realizedRecord: 1W / 10LWin rate: 9.1%Gross profit: +130 yenGross loss: -2,106 yenPayoff ratio: 0.62Max loss: -621 yenFloating P/L: -109 yenEquity impact: -2,085 yen
Today’s theme: the bots did not just lose, they failed to stop the bleeding
There are bad days where the market simply does not fit the strategy. Today felt a little different. GateGrid AI waited for its sell stops, got filled, and then both positions were closed several hours later for -330 yen and -403 yen. Seeing two losses and no offsetting wins is simple enough, but the long hold before the close is what caught my eye.
The LLM-driven side was also not clean. LLMBridgeTrader did produce the only winner of the day at +130 yen, which kept its payoff ratio above 2.0. But one strong exit cannot carry a sequence of six losses. The issue was not that every decision was poor. It was that the system kept finding new reasons to re-enter and then accept small damage again and again.
GateGrid AI: two trades, both wrong, no recovery
GateGrid AI took two GBPUSD sell entries in the morning and closed both in the afternoon. The final result was -733 yen, split into -330 yen and -403 yen. No winners, no partial recovery, no balancing trade. The -403 yen loss made me pause, because this bot has already shown that a single larger cut can wipe out a cluster of small wins on other days.
This bot is built to avoid weak entries. CatBoost filters the entry probability, while Ollama checks context such as ATR, spread, higher-timeframe trend, session, and recent performance. That design should reduce random exposure, but today it did not protect the exit. The sell idea stayed alive too long, or at least long enough for both positions to close at a size that hurt.
I am not sure yet whether the fix is earlier basket-level cancellation, a tighter emergency exit, or a more aggressive reversal check. The logs would need to confirm that. Still, from the realized result alone, the weak spot looks closer to “when to abandon the grid” than “whether the first sell stop was reasonable.”
BoundSniper Bot: one TradingView signal, one full loss
BoundSniper Bot had only one USDJPY trade. It bought at 162.314 and closed at 162.119, ending at -390 yen. With one trade, there is not much statistical meaning to pull out, but the loss size is worth noting.
BoundSniper is not an AI decision bot. It receives TradingView alerts, passes them through the local webhook setup, and sends the order to MT5. That means today’s result mainly reflects the upstream TradingView rule and its exit timing. The bot did its job as an execution bridge, but the strategy behind the signal did not get out cheaply.
This is the awkward part of automation. A bridge can be technically correct and still transmit a bad trade perfectly.
LLMBridgeTrader: one good win buried under six cuts
LLMBridgeTrader was the busiest bot today. It closed seven EURUSD trades: one win at +130 yen and six losses totaling -362 yen. The final realized result was -232 yen. The payoff ratio was 2.15, which is not bad by itself, but the win rate was only 14.3%. That mismatch tells the story.
This bot asks the LLM to make a broader trading plan. It does not only return BUY, SELL, or NONE. It also decides whether to OPEN, HOLD, CLOSE, or REVERSE, and provides confidence, setup type, SL/TP width, and reasoning. Today, the wider decision space may have created too many new attempts. Some losses were small, but repeated small losses still become a real daily hit.
The +130 yen exit shows that the model can catch a useful move. The problem is selectivity. It needs to be more willing to say NONE after a failed idea, or to wait longer before trying the next setup. That is my read for now, not a final diagnosis.
MLScore GF-T4 GB: the largest realized loss, then an open short left behind
MLScore GF-T4 GB realized -621 yen early in the day. The profit column showed -601 yen, and swap added another -20 yen. Later, it opened a new GBPJPY short that remained open at the report cutoff with -109 yen floating P/L. The closed side alone was already the largest single realized loss of the day.
Because there was only one closed trade, I do not want to overfit the analysis. Still, the size matters. A max loss of -621 yen is larger than the entire realized loss of LLMBridgeTrader, despite LLMBridgeTrader taking seven closed trades. That makes the risk profile feel uneven.
The new short position might recover later, but at the cutoff it was not helping. For this bot, the next thing to watch is whether the SL-side exit is too heavy relative to the expected TP. If the winner target is not large enough to pay for this kind of loss, the math stays fragile.
Closing thoughts
Today’s log was blunt. GateGrid AI missed twice. BoundSniper took one clean hit. LLMBridgeTrader had one good exit but kept paying for retries. MLScore carried the largest realized loss and still had an open drawdown.
The useful part is that the weakness is visible. This was not a mysterious day hidden behind a decent win rate. It was 1 win and 10 losses, with the exits doing most of the damage. Sometimes the honest read is the shortest one: the bots did not need more confidence today. They needed fewer second chances.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
Conclusion
The week ended at -2,007 yen, and the uncomfortable part is that the bots were not simply “bad at trading.” They found plenty of winning trades. GateGrid AI even had a day with a 93.3% win rate, which sounds almost too clean. But that number did not protect the portfolio.
The real problem was exit quality. Across the week, several bots showed the same pattern: small wins piled up, then one oversized loss cut through the progress. I do not think the lesson is “the entries failed.” The sharper lesson is that an automated strategy can be directionally right often enough and still lose money if it does not know when the original idea has expired.
Bot-by-bot weekly performance
■ GateGrid AIMain pair: GBPUSDWeekly theme: high win rate, weak loss controlNotable result: 93.3% win rate on June 30Key loss: -729 yen on June 29Main issue: one large grid loss erased many small wins
■ BoundSniper BotMain pair: USDJPYWeekly theme: execution was fine, signal-side exit risk was notNotable result: positive day on July 2 despite only 25.0% win rateKey loss: -771 yen on June 30Main issue: one late exit damaged the full portfolio
■ LLMBridgeTraderMain pair: EURUSDWeekly theme: strong planning when right, slow CLOSE when wrongNotable result: 6 wins out of 6 on July 1, +710 yenKey issue: holding losing ideas too long on weaker daysMain issue: AI needs better judgment for switching from HOLD to CLOSE
■ MLScore GF-T4Main pair: GBPJPYWeekly theme: low trade count, but open risk mattersNotable result: 0 yen realized on July 3Open risk: -211 yen unrealized loss on July 3Main issue: realized P/L alone did not show the actual account risk
■ Weekly totalPeriod: June 29–July 3Total realized result: -2,007 yenMain theme: exit discipline mattered more than entry accuracyMost uncomfortable pattern: high win rate did not prevent lossesNext focus: max-loss rules, earlier exits, and stricter trade invalidation
Today’s, or rather this week’s, theme
This week made the win rate feel a little dangerous. It is an easy number to like. It gives a sense of control. But the logs kept showing the same contradiction: the bots were often right, yet the account still moved in the wrong direction.
June 29 was the first warning. GateGrid AI had an 80.0% win rate and still finished at -400 yen because one -729 yen loss overpowered the smaller wins. I stopped on that number for a moment, because it is the kind of trade that makes every clean entry before it feel smaller than it looked.
June 30 made the point even harder. GateGrid AI produced 14 wins and only 1 loss, ending at +442 yen. But BoundSniper took a -771 yen hit, and the whole portfolio closed at -974 yen. That is the week in one sentence: one bot can behave well, and another bot’s exit can still decide the day.
GateGrid AI
GateGrid AI gave the clearest example of the win-rate trap. On some days it looked almost too good. A 93.3% win rate on June 30 is not something I want to dismiss. The CatBoost gate and Ollama judgment layer were clearly finding trades that could close green.
But the bad days were not small. June 29 had the -729 yen loss. July 2 ended with GateGrid AI down -845 yen despite winning 15 out of 23 trades. The problem was not a lack of winning trades. It was the size of the losing side.
For a grid-style bot, this is the oldest problem in the room: where do you give up? GateGrid AI is designed to avoid low-quality entries, and that still matters. But this week showed that “not entering badly” is only half the job. The other half is cutting the structure before the grid becomes a stubborn position.
BoundSniper Bot
BoundSniper Bot is simpler in design. It does not predict the market by itself. TradingView sends the signal, the webhook path passes it through, and MT5 executes. So when BoundSniper has a bad result, I look less at the execution engine and more at the signal and exit rules sitting upstream.
The contrast was sharp. On July 2, BoundSniper had only a 25.0% win rate, but still ended slightly positive at +14 yen because the payoff ratio was strong. That was a useful reminder: a low win rate is not automatically bad if the losses are controlled and the winners have room.
Then there was June 30. The -771 yen loss was too large for the role this bot should be playing in the portfolio. It felt less like a normal loss and more like a rule boundary being too loose. The fix is probably not in the webhook layer. It is in the TradingView-side stop, exit, or invalidation logic.
LLMBridgeTrader
LLMBridgeTrader had the most interesting week from an AI-experiment point of view. On July 1, it went 6 for 6 and made +710 yen. That is the version of the bot I want to study carefully, because the AI was not only entering. It was managing position actions through OPEN, HOLD, CLOSE, and sometimes REVERSE logic.
But the same freedom can cut both ways. On weaker days, the bot seemed too willing to keep holding after the trade idea had started to fail. This is where LLM trading becomes less about prediction and more about self-correction.
The main question for LLMBridgeTrader is not “can the model find a setup?” It can. The question is whether it can admit the setup is no longer valid. That is a harder judgment, and probably the one that matters more in live trading.
MLScore GF-T4
MLScore GF-T4 did not dominate the week by trade count, but it gave an important reminder on July 3. The realized P/L was 0 yen, which looks harmless on a closed-trade report. But there was a -211 yen unrealized loss sitting in the open position.
That is not just a footnote. In automated trading, open risk is still part of the result, even if the statement does not force you to count it yet. A system can look flat or even green in realized terms while carrying risk that will land in the next day’s report.
I do not want to overjudge the bot from one open position. Still, it changes how I want to write these logs. From now on, realized P/L alone is not enough. Open positions need to be treated as part of the daily and weekly story.
Summary
The week did not say, “the bots cannot win.” It said something more annoying: they can win often and still lose overall. That is a harder problem, because it means the entry layer is not useless. It is just not enough.
The next upgrade should not chase a prettier win rate. It should focus on max-loss limits, faster invalidation, and stricter exit rules. GateGrid AI needs clearer grid surrender conditions. BoundSniper needs tighter signal-side damage control. LLMBridgeTrader needs a better way to switch from HOLD to CLOSE when the market stops agreeing. MLScore GF-T4 needs open-risk visibility baked into the review.
The week’s loss was -2,007 yen. Small in scale, maybe. But the lesson was not small at all.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
The biggest result today was not the total loss itself. It was the shape of the loss. GateGrid AI won 15 out of 23 closed trades, which looks fine at first glance, then ended the day at -845 yen. I had to stop for a moment when I saw that number next to a 65.2% win rate, because this is exactly the kind of result that makes win rate feel comforting and dangerous at the same time.
Across the four bots, the realized result was -868 yen. If I include the open EURUSD position held by LLMBridgeTrader at -60 yen, the equity impact was -928 yen. BoundSniper and LLMBridgeTrader both finished positive on realized P/L, but the day was still decided by GateGrid’s heavier losing exits. The issue does not look like entry frequency alone. It looks more like the point where the system stops holding, cuts, flips, or unwinds.
Bot-by-bot results
■ GateGrid AI -845 yenRecord: 15W / 8LWin rate: 65.2%Gross profit: +873 yenGross loss: -1,718 yenPayoff ratio: 0.27Max loss: -408 yen
■ BoundSniper Bot +14 yenRecord: 1W / 3LWin rate: 25.0%Gross profit: +102 yenGross loss: -88 yenPayoff ratio: 3.48Max loss: -70 yen
■ LLMBridgeTrader +29 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +121 yenGross loss: -92 yenPayoff ratio: 0.66Max loss: -92 yenOpen position: -60 yen floating P/L
■ MLScore GF-T4 GB -66 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +250 yenGross loss: -316 yenPayoff ratio: 0.79Max loss: -316 yen
■ Total -868 yen realizedRecord: 19W / 13LWin rate: 59.4%Gross profit: +1,346 yenGross loss: -2,214 yenPayoff ratio: 0.42Max loss: -408 yenFloating P/L: -60 yenEquity impact: -928 yen
Today’s theme: the entry was not the only decision
I usually look at these bots through the lens of whether the model entered too early, too late, or not at all. Today pushed me back toward a less comfortable place: exit quality. A system can be right often enough and still bleed if the average winner is too small and the losing trades are allowed to stretch.
GateGrid AI is the cleanest example. It uses CatBoost as the first gate, then Ollama as the second layer of judgment, with ATR, spread, session, recent win rate, recent P/L, and higher-timeframe trend information in the prompt. That design is meant to avoid bad entries, and in a narrow sense it did not look terrible. But the payoff ratio was only 0.27, which is hard to ignore. The bot was taking small wins, then giving back several of them in one wider loss.
GateGrid AI: good hit rate, poor damage control
GateGrid AI closed 23 trades, with 15 winners and 8 losers. The winners added up to +873 yen, while the losers totaled -1,718 yen. That imbalance says more than the win rate. The average win was 58.2 yen, and the average loss was 214.8 yen. When I see -408 yen as the largest single loss, it feels less like one unlucky print and more like a warning about the exit band.
This bot is built around selective participation. CatBoost screens the market, Ollama judges the risk context, and the grid parameters adapt around volatility. The problem today was not that it traded blindly all day. It was that once several baskets turned against it, the realized cuts were too large compared with the clipped profits. I do not want to overstate it from one day of data, but the exit side is probably where the next adjustment belongs.
BoundSniper Bot: ugly win rate, better trade math
BoundSniper Bot had the opposite personality today. It won only 1 of 4 trades, which looks weak, but still ended at +14 yen. The one winning trade was +102 yen, while the three losses were small: -6, -12, and -70 yen. A 25.0% win rate is not pleasant to look at, but the payoff ratio was 3.48, and that gave the bot room to survive.
This bot is not trying to think. TradingView sends the signal, the local webhook receives it, and MT5 executes. In that sense, the result is more about whether the upstream TradingView logic kept the losses tight enough. Today it did. I would not call this strong performance, but the loss design was healthier than GateGrid’s.
LLMBridgeTrader: realized profit, but one open question remains
LLMBridgeTrader closed 3 trades: +52 yen, -92 yen, and +69 yen. Realized P/L was +29 yen, with a 66.7% win rate and a payoff ratio of 0.66. On the surface that is fine, but the bot also carried one open EURUSD buy position with -60 yen floating P/L at the report cutoff.
This bot gives the LLM a wider role. It does not only ask for BUY, SELL, or NONE. It also asks whether to OPEN, HOLD, CLOSE, or REVERSE, together with confidence, setup type, SL pips, TP pips, and the reasoning behind the plan. That makes today’s open position interesting. The realized trades were controlled, but the real test is whether the model knows when HOLD stops being patience and starts becoming delay. I do not have enough from this report alone to judge that last position, but that is exactly where the experiment lives.
MLScore GF-T4 GB: one swap-hit loss erased the clean TP
MLScore GF-T4 GB had only two closed outcomes. One was a stop-side close with swap included at -316 yen, and the other was a take-profit at +250 yen. The final result was -66 yen. It is a small daily loss, but the structure is plain: one heavier losing close outweighed the clean winner.
A 50.0% win rate with a 0.79 payoff ratio is not broken beyond repair, but it does not leave much margin. The bot needs either a slightly larger average winner, a smaller stop-side loss, or fewer swap-damaged exits. The +250 yen TP was not bad. It just did not fully pay for the earlier damage.
Closing thoughts
Today’s log made the same point in four different accents. BoundSniper showed that a low win rate can survive when the losing trades stay small. GateGrid showed that a high win rate can still lose when one exit absorbs several wins. LLMBridgeTrader stayed positive on realized trades, but the open position is the part I want to watch next.
For these LLM and ML-driven MT5 bots, the question is not only “was the entry intelligent?” The harder question is whether the system knows when the original idea has expired. Today, that answer was mixed, and GateGrid paid the bill.
This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com -
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.
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 -
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.
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 -
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.
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 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.
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 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?”
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 -
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
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 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.
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 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.
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 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.
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 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
- Laat meer zien
