AI FX Bot Lab: Real Trading Experiments

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.