My five MT5 trading bots finished July 20 with a combined realized loss of ¥542.

The closed trades produced three wins and five losses. The average winning trade made ¥32.7, while the average losing trade lost ¥128. That gives an average payoff ratio of only 0.26.

BoundSniper Bot was the only system to finish positive, earning ¥16.

GateGrid AI lost ¥151, LLMBridgeTrader lost ¥167, and ML_ScoreAnalyst lost ¥240. I did not receive a confirmed report for MAribbonTrader, so I recorded it as an unverified ¥0 rather than assuming that it made no trades.

When I first reviewed the day, I thought the main issue was the exit logic.

Several different bots were producing the same pattern: small profits were closed quickly, while larger losses were allowed to remain.

That interpretation was not completely wrong.

However, after a deeper investigation into GateGrid AI, I reached a different conclusion.

The exits were weak, but improving them was not enough. Better entry selection was not enough either.

The GBPUSD version of the strategy could not produce a positive expected value under realistic trading costs.

The real issue was not simply how intelligent the bot was.

It was the relationship between the strategy, the currency pair, and the cost paid on every trade.

The July 20 loss became the final reason to reconsider whether GateGrid AI should continue trading GBPUSD at all.

Results by Bot

GateGrid AI: -¥151

GateGrid AI traded GBPUSD and finished with zero wins and two losses.

A buy stop was triggered first. The sell-side order was then triggered as well, and both positions were closed roughly one second later.

The two results were -¥135 and -¥16.

Looking only at this sequence, the problem appeared to be the position-management process after the opposite side was filled.

Should the system keep both positions as a hedge?

Should it treat the second fill as a reversal and close the first position?

Should it classify the situation as abnormal and close everything?

The trade report did not show which rule caused the exit.

In the past, I would have responded by adding more detailed exit logs and adjusting the position-management logic.

In fact, I had already made many such adjustments.

The long-term performance still failed to improve.

BoundSniper Bot: +¥16

BoundSniper Bot traded USDJPY.

It bought at 162.348 and closed approximately four minutes later at 162.364, producing a ¥16 profit.

One trade is not enough to evaluate the quality of the underlying signal.

However, the execution path worked correctly. The bot received the TradingView webhook, placed the MT5 order, closed the position, and left nothing open.

BoundSniper Bot does not predict the market by itself. Its job is to carry an external TradingView signal into MT5.

For that reason, the important risks are different: communication latency, duplicate orders, symbol conversion failures, rejected orders, and missed exits.

The profit was small, but the execution process was clean.

LLMBridgeTrader: -¥167

LLMBridgeTrader traded EURUSD.

Its three results were -¥141, +¥73, and -¥99.

That produced one win and two losses. The average win was ¥73, while the average loss was ¥120, giving an average payoff ratio of 0.61.

All three positions were closed at market before reaching their original stop-loss or take-profit levels.

This suggests that the LLM-based OPEN, HOLD, CLOSE, and REVERSE decision process was active.

But an active decision process is not necessarily a profitable one.

Did the model close profitable trades too early?

Did it correctly detect a reversal?

Did it wait longer when a position was losing than when it was winning?

The trade history alone cannot answer those questions.

The system needs to record the model name, prompt version, market inputs, confidence score, proposed action, final action, and exact exit reason for every decision.

ML_ScoreAnalyst: -¥240

ML_ScoreAnalyst traded GBPJPY.

It produced one ¥9 profit and one ¥249 loss.

Its average payoff ratio was only 0.04.

It would take nearly 28 wins of ¥9 to recover a single ¥249 loss.

This bot uses a CatBoost score to select entries. However, a high entry score is not enough when the expected price movement is much smaller than the stop-loss distance.

Raising the score threshold alone will not solve the problem.

The score threshold, trading session, ATR, entry volatility, stop distance, and target distance need to be tested as one combined policy.

The bot also carried an unrealized loss of ¥97 into the next day.

That unrealized amount was not included in the realized loss of ¥542. Including it would bring the total daily mark-to-market result to -¥639.

MAribbonTrader: Unverified ¥0

I did not receive a July 20 trade report for MAribbonTrader.

I therefore recorded it as an unverified ¥0 rather than declaring that it made no trades.

For an LLM bot that reads chart images, BUY and SELL are not the only meaningful outputs.

WAIT and EXIT are also decisions.

The input image, higher-timeframe context, support and resistance levels, model response, and reason for waiting should all be recorded.

A day with no trades can still contain valuable information, but only if the system distinguishes between deliberately waiting and failing to run.

GateGrid AI Was Winning Most Trades and Still Losing Money

I did not judge GateGrid AI from the two losses on July 20 alone.

Across its live trading history, the bot won approximately 62–68% of its trades.

At first glance, that appears acceptable.

Despite that win rate, its live profit factor was only 0.62, and its lifetime loss was approximately ¥19,000.

The problem was not just an occasional large loss.

The system was losing small amounts on an almost daily basis.

Converted into pips, the average winning trade made only 4.3 pips, while the average losing trade lost 15.3 pips.

The average loss was roughly 3.5 times larger than the average win.

With that payoff structure, the break-even win rate is approximately 78%.

The actual win rate of 62–68% was not close enough.

A minor improvement in entry accuracy could not bridge the gap.

This asymmetry was not simply a programming bug.

GateGrid AI closes profitable positions relatively quickly and adds exposure when the market moves against the grid.

Small gains are collected frequently, but losing baskets become much heavier.

The negative skew was embedded in the strategy itself.

GBPUSD Trading Costs Were Too Large Relative to the Average Win

Spread was another factor quietly damaging the system.

In live observations, GBPUSD spread sometimes reached roughly 1.2 pips.

For a strategy whose average winning trade was only 4.3 pips, that cost was substantial.

A 1.2-pip spread consumes about 28% of the gross winning distance.

In my cross-pair simulations, I used a 0.7-pip spread for GBPUSD. Even under that more favorable assumption, it remained expensive compared with the roughly 0.3-pip conditions available on EURUSD and USDJPY.

For a strategy targeting large moves, a difference of 0.4 pips may be relatively minor.

For a system repeatedly collecting around four pips, that difference sits near the center of the expected value calculation.

Reducing the spread paid on every trade can matter more than improving entry accuracy by a few percentage points.

I Had Already Made Extensive Exit Adjustments

GateGrid AI’s exits had not been ignored.

I increased the trailing ratchet from 0.7 to 0.9.

I added a time-decay mechanism that gradually reduced the global stop-loss distance to 15 pips after 180 minutes.

I introduced an ¥800 basket loss limit.

I blocked new entries on Mondays and before the trading curfew.

These changes reduced the size of the tail losses.

However, they did not close the gap between the required 78% win rate and the actual win rate of roughly 68%.

Exit adjustments could reduce the severity of the losses, but they could not reverse the expected value of the strategy.

That left one remaining possibility: improve the entries.

Six Attempts to Improve Entry Quality Failed

I used one rule for every experiment.

A change would only be accepted if it improved performance consistently across multiple periods.

A policy that worked in only one selected period would not be considered valid.

Regime Switching

I tested a model designed to classify whether the market was ranging or breaking out and then change the grid behavior accordingly.

The holdout AUC was 0.57, and the resulting trading policy showed no improvement.

The model could describe something resembling market conditions, but it could not separate profitable conditions from unprofitable ones.

Gate Model Version 2

I used 16,715 previously unused market snapshots and generated counterfactual labels to rebuild the entry gate.

The real holdout AUC reached 0.61.

Despite the higher classification score, the trading policy became worse by ¥46 per trade.

A model can improve its statistical metric while reducing actual trading performance.

This experiment also revealed that the existing combined policy of threshold filtering, Ollama judgment, and the clean gate was better than simply sorting trades by the model score.

Replacing the LLM

I attempted a shadow test using gpt-oss:20b in place of the current Ollama decision model.

Under the current configuration, however, the model returned empty responses.

It appeared faster...