AI FX Bot Lab: Real Trading Experiments

The result for June 18 was simple, but a little uncomfortable: four MT5 auto-trading bots closed the day at -464 yen. The portfolio won 27 out of 36 trades, so the surface number looked fine. Still, the payoff ratio was only 0.27, and that is where the day fell apart.

This was not a day where the bots failed to find entries. They found plenty. The real question was whether they knew when to stop believing those entries. I think the problem sits mostly at the exit, though the evidence is not perfectly clean yet.

Bot-by-bot results

■ GateGrid AI -155 yenSymbol: GBPUSD-Closed trades: 21Record: 17W / 4LWin rate: 81.0%Gross profit: +955 yenGross loss: -1,110 yenPayoff ratio: 0.20Max loss: -443 yen

■ BoundSniper Bot +20 yenSymbol: USDJPY-Closed trades: 7Record: 6W / 1LWin rate: 85.7%Gross profit: +446 yenGross loss: -426 yenPayoff ratio: 0.17Max loss: -426 yen

■ LLMBridgeTrader -92 yenSymbol: EURUSD-Closed trades: 5Record: 3W / 2LWin rate: 60.0%Gross profit: +348 yenGross loss: -440 yenPayoff ratio: 0.53Max loss: -241 yen

■ MLScore GF-T4 GB -237 yenSymbol: GBPJPY-Closed trades: 3Record: 1W / 2LWin rate: 33.3%Gross profit: +265 yenGross loss: -502 yenPayoff ratio: 1.06Max loss: -252 yen

■ Total -464 yenClosed trades: 36Record: 27W / 9LWin rate: 75.0%Gross profit: +2,014 yenGross loss: -2,478 yenPayoff ratio: 0.27Max loss: -443 yenSeries day: Day 1 in this provided logCumulative P&L: -464 yen

Today’s theme: entry confidence did not protect the downside

The most interesting contrast was not between winners and losers. It was between win rate and damage size. GateGrid AI won more than 80% of its exits, but still ended negative. BoundSniper Bot won almost everything and barely escaped positive. Seeing a -443 yen single loss inside GateGrid made me pause, because the rest of the day was mostly small repairs.

The ML score bot was even more direct. The GBPJPY engine printed candidate=SELL decision=ENTER signal=SELL score=95.09 trade=done, but that first SELL later closed at -252 yen. A score over 95 feels strong on screen. In the account report, it was just the first of two stop losses before the final win.

GateGrid AI

GateGrid AI’s final number was -155 yen, but that result hides a rough start. The first two closed trades were -379 yen and -443 yen, and the log says it plainly: [CAP] Basket max-loss exit: pnl=-822.00 <= -800.00. That line has more weight than the final daily total. The bot spent the rest of the session clawing back small profits, but the early basket damage was too large.

The win rate was 81.0%, which sounds good until the payoff ratio shows up at 0.20. Average winners were small; average losers were too heavy. This is the kind of day where the grid logic can look active and controlled, while the account curve is still paying for one bad pocket of exposure.

BoundSniper Bot

BoundSniper Bot was the only bot to finish positive, but only by +20 yen. That number is almost funny after a 6W / 1L record. I had to look twice, because a win rate of 85.7% usually feels like it should leave more behind.

The explanation is blunt: six wins made +446 yen, and one loss took back -426 yen. Payoff ratio was 0.17. BoundSniper is not using the same kind of LLM planning as LLMBridgeTrader, so I do not want to force the “AI exit” story onto it. But as a trading system, it is showing the same design issue: one bad exit can consume a clean run of small closes.

LLMBridgeTrader

LLMBridgeTrader lost -92 yen, but it gave the most useful AI log of the day. Near the final EURUSD trade, the model opened a BUY with a mean-reversion setup: RSI oversold bounce in weak ranging market. Then, fifteen minutes later, it chose to close with position_action":"CLOSE" and the exit reason Weak ADX and bearish structure favor closing. That close finished as a +90 yen trade.

This is the part I like. The bot was not only saying BUY or SELL. It was also changing its mind about holding the position. The full day was still negative because the earlier two losses were larger than the later wins, but the exit behavior itself was not random. It saw weak trend conditions and got out. That is closer to the experiment I want this bot to run.

MLScore GF-T4 GB

MLScore GF-T4 GB had the lowest win rate at 33.3%, yet its payoff ratio was the best of the group at 1.06. That sounds contradictory, but it fits the trades: two losses around -250 yen, then one win at +265 yen. The structure was not terrible. The timing was.

The entries were all SELL signals with strong scores, including 95.09, 92.89, and 93.5. The issue is that high score did not mean high follow-through. If this bot keeps using score as the main gate, the next layer probably has to judge when a high-score setup is already late.

Wrap-up

The day ended at -464 yen. Not a disaster, but not a clean loss either. The strange part is that the portfolio was right often enough. It just did not get paid enough when right, and it paid too much when wrong.

For this series, today’s lesson is not “raise the win rate.” The bots already did that. The better question is whether each bot can recognize the moment when its original idea has expired. That is where the next improvement probably lives.

Conclusion

June 17 was not a “win rate day.” The four MT5 bots ended at -1,615 yen, and the strange part is that the bot with a 33.3% win rate, LLMBridgeTrader, lost less than GateGrid AI at 50.0%. I had to look twice at that. The answer was not hidden in the entry count. It was in payoff ratio and the size of the worst exits.

For this pasted record, I am treating it as Day 1 / cumulative -1,615 yen, because no earlier running total was included. The combined final balance across the four MT5 accounts was 169,127 yen after the day’s trades.

Bot Results

■ GateGrid AI -712 yenPair: GBPUSD-Record: 2W / 2LWin rate: 50.0%Gross profit: +84 yenGross loss: -796 yenPayoff ratio: 0.11Max loss: -431 yen

■ BoundSniper Bot -32 yenPair: USDJPY-Record: 2W / 2LWin rate: 50.0%Gross profit: +64 yenGross loss: -96 yenPayoff ratio: 0.67Max loss: -88 yen

■ LLMBridgeTrader -466 yenPair: EURUSD-Record: 3W / 6LWin rate: 33.3%Gross profit: +713 yenGross loss: -1,179 yenPayoff ratio: 1.21Max loss: -245 yen

■ MLScore GF-T4 GB -405 yenPair: GBPJPY-Record: 1W / 2LWin rate: 33.3%Gross profit: +205 yenGross loss: -610 yenPayoff ratio: 0.67Max loss: -353 yen

■ Total -1,615 yenPairs: GBPUSD- / USDJPY- / EURUSD- / GBPJPY-Record: 8W / 12LWin rate: 40.0%Gross profit: +1,066 yenGross loss: -2,681 yenPayoff ratio: 0.60Max loss: -431 yen

Today’s Theme: Win Rate Did Not Protect the Account

GateGrid AI and BoundSniper both ended with a 50% win rate. That sounds acceptable at first glance. But GateGrid’s average win was only 42 yen, while its average loss was 398 yen. Seeing -431 yen as the largest single loss made the whole day feel different. This was not a small miss. It was a payoff structure problem.

LLMBridgeTrader looked worse by win rate. It only won 3 out of 9 exits. But its payoff ratio was 1.21, the only bot above 1.0 today. That did not save the day, but it kept the damage from becoming the worst result on the board. The exits were still noisy, and I do not want to overpraise a losing bot. Still, the shape was healthier than the headline win rate suggested.

Bot-by-Bot Analysis

GateGrid AI

GateGrid AI had the cleanest warning sign of the day. Two winners, two losers, and still -712 yen. The winners were +74 yen and +10 yen. The losers were -365 yen and -431 yen. When the wins are that small, even a decent entry filter cannot carry the system.

This bot is designed to filter entries through CatBoost and Ollama. The design notes include logs like AI_SKIP(sess=NY gate=0.50 base_thr=0.54 adj_thr=0.55) and OLLAMA_HOLD, which show that the bot is supposed to avoid bad setups instead of always trading. Today’s report does not include the full live reasoning trace behind the two GBPUSD exits, and that missing context matters. Without the actual decision text, I can only say this much: the entry side may have passed the filters, but the exit side let the losing grid grow too large compared with the take-profit size.

BoundSniper Bot

BoundSniper was almost flat, but not in the clean way. The price-side closing profit totaled +102 yen, yet swap of -134 yen pulled the final result down to -32 yen. That little reversal is easy to ignore, but it is the kind of cost that slowly changes the personality of a strategy.

This bot is not making AI decisions. It receives TradingView signals and sends them to MT5. The comments were simple execution markers such as BoundSniper OPEN and BoundSniper clos. That simplicity is useful because there is less ambiguity. If the day goes wrong here, the question is usually not “what did the LLM think?” but whether the TradingView rule and holding time still make sense after costs.

LLMBridgeTrader

LLMBridgeTrader is the most interesting loser today. The record was bad on the surface: 3 wins and 6 losses. But the biggest loss was -245 yen, while the biggest win was +399 yen. That is why it lost less than GateGrid despite a lower win rate. I did not expect the “uglier” win rate to produce the more controlled loss.

The execution comments show multiple exits labeled like [sl 1.15813], [tp 1.15665], and [sl 1.14949]. One confusing part is that some [sl] exits were profitable, such as +157 yen. That probably reflects stop adjustment or the way MT5 comments preserve the order label, not a simple “SL equals loss” story. For an LLM-driven bot, this is exactly where the next layer of logs is needed: why did the AI keep holding, close, or allow the stop to sit where it did?

MLScore GF-T4 GB

MLScore GF-T4 GB finished at -405 yen with 1 win and 2 losses. The first close had swap -78 yen and price loss -275 yen, so the net damage of that one exit was -353 yen. That one stung more than the trade count suggests.

The middle trade did work, closing at +205 yen, but the second loss at -257 yen erased it and then some. The structure looked similar to BoundSniper in payoff ratio, but with a larger max loss. It needs either a better loss cap or a reason to avoid the second entry after the first session had already absorbed damage.

Summary

The day was negative, but it was not evenly negative. GateGrid AI looked reasonable by win rate and weak by payoff. LLMBridgeTrader looked weak by win rate and more defensible by loss shape. That is the uncomfortable part of running these bots side by side: the number that feels easiest to understand is not always the number that tells the truth.

Editor’s note to myself: next time, paste the full AI decision logs with confidence, setup type, OPEN/HOLD/CLOSE/REVERSE reason, and exit reason.

June 16, 2026 was not a “bad entries” day as much as an “exit discipline” day. Across the four MT5 bots, the combined realized result was -1,445 yen, even though the total win rate was still 53.3%. That number made me pause a bit, because more trades won than lost, and yet the day still bled out.

For this series ledger, I am treating the pasted history as Day 1: cumulative realized P/L is -1,445 yen. Open unrealized P/L was not included in that total. BoundSniper still had -30 yen floating, and MLScore GF-T4 GB had -124 yen floating, so the unfinished part of the day was not exactly clean either.

Bot-by-bot results

■ GateGrid AI -703 yen

Pair: GBPUSD-

Closed trades: 4

Record: 2W / 2L

Win rate: 50.0%

Gross profit: +93 yen

Gross loss: -796 yen

Payoff ratio: 0.12

Max loss: -432 yen

■ BoundSniper +3 yen

Pair: USDJPY-

Closed trades: 3

Record: 2W / 1L

Win rate: 66.7%

Gross profit: +162 yen

Gross loss: -159 yen

Payoff ratio: 0.51

Max loss: -159 yen

■ MLScore GF-T4 GB -487 yen

Pair: GBPJPY-

Closed trades: 4

Record: 2W / 2L

Win rate: 50.0%

Gross profit: +351 yen

Gross loss: -838 yen

Payoff ratio: 0.42

Max loss: -600 yen

■ LLMBridgeTrader -258 yen

Pair: EURUSD-

Closed trades: 4

Record: 2W / 2L

Win rate: 50.0%

Gross profit: +135 yen

Gross loss: -393 yen

Payoff ratio: 0.34

Max loss: -249 yen

■ Total -1,445 yen

Scope: realized closed trades only

Closed trades: 15

Record: 8W / 7L

Win rate: 53.3%

Gross profit: +741 yen

Gross loss: -2,186 yen

Payoff ratio: 0.30

Max loss: -600 yen

Today’s theme: the exit beat the win rate

The headline is not just the loss. The stranger part is that the bots won 8 out of 15 closed trades and still ended at -1,445 yen. A total payoff ratio of 0.30 means the average winner was too small compared with the average loser. I do not think the entry side gets cleared completely, but the exit side is where the damage shows up first.

GateGrid AI and MLScore GF-T4 GB both finished at a 50.0% win rate. But GateGrid’s two wins totaled only +93 yen, while its two losses totaled -796 yen. MLScore looked slightly healthier on winners, with +351 yen of gross profit, but the -600 yen loss hit like the kind of print you do not just scroll past.

The design notes for GateGrid say the bot is built to leave a reason trail, including messages like AI_SKIP(sess=NY gate=0.50 base_thr=0.54 adj_thr=0.55) and OLLAMA_HOLD. That is exactly the kind of log I wanted beside today’s trades. The MT5 export tells me where the damage happened, but not enough about why the model stayed in, closed there, or failed to avoid the bad sequence.

GateGrid AI

GateGrid AI was the heaviest drag of the day at -703 yen. The first two exits were small wins, +85 yen and +8 yen, which is fine on paper but too small to matter once the later pair of losses arrived. When I saw -364 yen and -432 yen printed back to back, the earlier +93 yen stopped feeling like progress.

This is a payoff problem before it is a win-rate problem. A 50.0% win rate can work if the average win and average loss are balanced, but here the payoff ratio was only 0.12. The grid did take profit when it had a chance, but the losing leg widened far beyond the winning leg. My suspicion is exit timing or trailing behavior, not the mere fact that it entered.

The architecture is meant to filter entries through CatBoost and then use Ollama for situational judgment. That design is still attractive, because a bot that can say OLLAMA_HOLD has at least some mechanism for refusing trades. Today’s report, though, only shows the final broker-side outcome. Without the actual decision log, I cannot tell whether the AI wanted to hold, whether the trailing logic waited too long, or whether the grid structure simply accepted too much downside.

BoundSniper

BoundSniper was the only realized winner, but only by +3 yen. That number almost feels like a joke, not because it is bad, but because it survived while the more complex bots took the larger hits. The first close had a loss plus swap cost, then the next two closes recovered enough to end slightly positive.

This bot is not trying to be smart in the same way. It passes TradingView signals to MT5, so the performance review belongs mostly to the upstream strategy and execution reliability. Still, the payoff ratio was 0.51, better than the day’s total, and the largest loss was contained at -159 yen. That boring containment mattered.

The open USDJPY- short was still floating at -30 yen at the report cutoff. I did not include that in realized P/L, but I would not ignore it either. BoundSniper’s job is clean execution, and today it did that well enough to avoid becoming the story.

MLScore GF-T4 GB

MLScore GF-T4 GB had the day’s largest single realized loss at -600 yen. That one trade shaped the whole read. The bot had two winners, +151 yen and +200 yen, so it was not failing every time it touched the market. Still, one oversized loss swallowed both winners and left the bot at -487 yen.

This is where the “50% win rate” line becomes almost misleading. Two wins and two losses can be perfectly acceptable, but only if the losses are not three times the wins. The payoff ratio was 0.42, which is not hopeless, yet the max loss was too large relative to the rest of the day.

The report also showed an open GBPJPY- sell with -124 yen unrealized at cutoff. That makes the exit question harder to ignore. The closed book already had one oversized stop, and the open book was still underwater. I would want to inspect whether the stop width is static, volatility-adjusted, or simply too generous for the current GBPJPY movement.

LLMBridgeTrader

LLMBridgeTrader ended at -258 yen, with the same 2W / 2L pattern. The difference is that the losses were smaller than MLScore’s and GateGrid’s largest hits, but the wins were also small. A payoff ratio of 0.34 is still too thin.

The bot design says it can return not only BUY / SELL / NONE, but also OPEN, HOLD, CLOSE, and REVERSE, along with confidence, setup type, SL pips, TP pips, and entry or exit reasons. That is the part I most want to read on a day like this. The MT5 comments only preserved LLMBridgeTrader_, so I can see the executed trades, but not the reasoning that led to closing at -144 yen or taking the later +77 yen and +58 yen.

For an AI-led bot, the entry is only half the experiment. The more interesting question is whether the model knows when its original idea has expired. Today’s LLMBridge result was not catastrophic, but it still leaned toward small winners and larger losers. That pattern needs a stronger close-or-hold audit.

Summary

The day did not collapse because every bot was wrong. It collapsed because the losing trades were allowed to become too heavy relative to the winners. BoundSniper, the least “AI-planner” style bot, was the only one to end positive, and that is a little uncomfortable.

The next review should focus less on signal accuracy and more on the moment each bot decides that a trade is no longer worth holding. That is where the money left the account today.

Editor’s note: next time, paste the actual AI decision logs too. The numbers are enough to score the day, but the logs are what turn it into a real LLM trading experiment.

June 15, 2026Running log: Day 1Cumulative realized P/L: +282 yenEquity impact including open positions: +46 yen

The portfolio finished green, but the most interesting part of the day was not the profit. It was the restraint. Four MT5 bots ended with +282 yen in realized P/L, yet open positions dragged -236 yen, leaving the equity impact at only +46 yen. That number made the day feel thinner than the win rate suggested.

The cleanest lesson came from the logs. BoundSniper executed its TradingView signals cleanly, MLScore allowed one BUY but blocked other high-score candidates, and LLMBridgeTrader had one AI plan rejected because the proposed risk settings were invalid. The line that stuck with me was not a winning exit. It was the safety layer saying: sl_pips out of range: -12.34; reward/risk too low: -1.30.

Bot Results

■ GateGrid AI +67 yenPair: GBPUSD-Closed trades: 8Record: 6W / 2LWin rate: 75.0%Gross profit: +461 yenGross loss: -394 yenPayoff ratio: 0.39Max closed loss: -264 yenFloating P/L: 0 yen

■ BoundSniper Bot +182 yenPair: USDJPY-Closed trades: 2Record: 2W / 0LWin rate: 100.0%Gross profit: +182 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: 0 yenFloating P/L: -34 yen

■ LLMBridgeTrader +33 yenPair: EURUSD-Closed trades: 2Record: 2W / 0LWin rate: 100.0%Gross profit: +33 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: 0 yenFloating P/L: -141 yen

■ MLScore GF-T4 GB 0 yenPair: GBPJPY-Closed trades: 0Record: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: N/AFloating P/L: -61 yen

■ Total +282 yenClosed trades: 12Record: 10W / 2LWin rate: 83.3%Gross profit: +676 yenGross loss: -394 yenPayoff ratio: 0.34Max closed loss: -264 yenFloating P/L: -236 yenEquity impact: +46 yen

Today’s Theme: Score Is Not Permission

MLScore GF-T4 GB gave the day a sharper angle. Its guard settings were explicit: score threshold 80, max spread 20 points, max 4 new entries per day, and strategy-level entry limits. Then the live log showed a BUY with score 85.33 marked trade=done, while later candidates such as SELL score 96.24 and BUY score 84.32 were marked trade=blocked. That is a good kind of friction. A high score was not allowed to become an automatic order just because the number looked strong.

LLMBridgeTrader showed a similar kind of guardrail, but from a different layer. The AI produced a confident-looking plan: Strong bullish trend with ADX and rising MACD, with signal BUY, action OPEN, confidence 85, and setup trend_follow. Then the validator killed it because sl_pips was negative and the reward/risk calculation was broken. I liked that more than I expected. A model can sound convincing, but the system still needs a boring rule that says no.

Later, another LLMBridgeTrader plan did open a BUY: Oversold RSI 33 with bullish zone signal despite bearish trend, confidence 72, setup mean_reversion, SL 15 pips and TP 30 pips. That trade was still open at the report cut and showed -141 yen floating P/L. This is where the day stops being neat. The same bot had a safety layer strong enough to reject a bad AI plan, but the accepted plan still left the biggest floating wound of the day.

Bot-by-Bot Analysis

GateGrid AI did the most trading and carried the only closed losses. Six wins out of eight sounds comfortable, but the payoff ratio was only 0.39. The -264 yen loss made me stop for a second, because it outweighed several of the small wins. GateGrid’s design is built around not entering bad environments, using CatBoost and Ollama-style filters, but once a grid leg goes wrong, the loss profile still matters more than the headline win rate.

BoundSniper Bot was the clean execution story. The monitor showed public health as OK, and the recent trade decisions were all marked Request executed. It opened a short, closed it, opened a long, closed it, and later opened another short that remained floating at -34 yen. Since this bot is not trying to predict the market itself, I read the day as a clean bridge between TradingView signals and MT5 execution.

LLMBridgeTrader was the most revealing bot. Its realized result was 2W / 0L for +33 yen, but the open EURUSD position sat at -141 yen. The AI side did something right by having one bad plan blocked, yet the accepted mean-reversion BUY was still underwater at the cut. The uncomfortable question is not whether the AI can enter. It is whether the exit logic can stop a valid-looking idea from quietly overstaying.

MLScore GF-T4 GB had no closed result, but its log was probably the most useful one for design review. A BUY score of 85.33 became a live trade, while higher-scoring or still-qualified signals were blocked. That feels annoying in the moment, but it is exactly the kind of behavior a real-money bot needs. The -61 yen floating loss is small, though I would not ignore it just because the realized P/L is zero.

Summary

The day ended green, but the strongest signal was restraint. The realized win rate was 83.3%, yet the payoff ratio was only 0.34 and the floating drag nearly erased the closed profit. The bots can win trades. The better question now is which guardrails deserve to be stricter, and which ones are already saving the account from trades that looked good on paper.

Conclusion

Today’s combined result for the four MT5 auto-trading bots was +3 yen. On the surface, that is almost flat, and I paused for a second because the number looks too small to say much. But the inside of the day was not small at all.

GateGrid AI finished at -304 yen. The other three bots absorbed that loss with a combined +307 yen, leaving the portfolio slightly positive. This was not a big winning day. It was a day that showed why I do not want to judge these bots by win rate alone.

Series status: operation day not supplied / input-based cumulative P&L: +3 yen.

Bot-by-bot results

■ GateGrid AI -304 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +197 yenGross loss: -501 yenPayoff ratio: 0.10Max loss: -501 yen

■ MLScore GF-T4 GB +189 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +202 yenGross loss: -13 yenPayoff ratio: 15.54Max loss: -13 yen

■ LLMBridgeTrader +32 yenRecord: confirmed trades onlyWin rate: not calculatedGross profit: +32 yenGross loss: unconfirmedPayoff ratio: not calculatedMax loss: unconfirmed

■ BoundSniper +86 yenRecord: aggregate result onlyWin rate: not calculatedGross profit: +86 yenGross loss: unconfirmedPayoff ratio: not calculatedMax loss: unconfirmed

■ Total +3 yenRecord: not comparable because reporting depth differs by botWin rate: not comparableGross profit: +517 yenGross loss: -514 yenPayoff ratio: not comparableMax loss: -501 yen

Today’s theme

The theme today is simple, but it hurts a bit: win rate lied.

GateGrid AI won 4 out of 5 trades. An 80.0% win rate looks clean on paper. MLScore GF-T4 GB, on the other hand, went 1 win and 1 loss, only 50.0%. If I only looked at win rate, GateGrid would look like the better bot.

The money said something else. GateGrid AI ended at -304 yen, while MLScore GF-T4 GB ended at +189 yen. The difference was not entry frequency. It was the shape of the exits: one bot let a single loss become too large, while the other kept the losing side almost harmless.

The log also makes this day more interesting. MLScore printed: [2026-06-12 22:15:04] GBPJPY M15 | candidate=BUY decision=ENTER signal=BUY score=96.43 trade=done. Later, it also printed a high-score blocked signal: [2026-06-12 22:45:01] GBPJPY M15 | candidate=SELL decision=ENTER signal=SELL score=95.9 trade=blocked. That second line matters. The engine found a candidate, the score was high, but the guard did not let it through. Today, that kind of refusal may have been as valuable as the entry itself.

GateGrid AI

GateGrid AI ended at -304 yen.

The four winning trades were +83 yen, +16 yen, +80 yen, and +18 yen. Total profit was +197 yen. That part was not bad. Then came the -501 yen loss, and I honestly stopped there for a moment. One losing trade erased all four wins and pushed the bot negative.

This is the weak point of the day. GateGrid AI can take small profits, but today’s exit behavior did not protect the session. Average profit was 49.25 yen. The largest loss was -501 yen. That gap is too wide for an 80% win rate to rescue.

The design of GateGrid AI is not just a plain grid. It combines CatBoost entry gating, local Ollama judgment, ATR checks, spread monitoring, session thresholds, and grid management. The idea is to avoid bad entries and build only when the environment is acceptable. But today’s issue was probably not the entry gate. It was the point where the bot should have stopped holding the pain.

For the next iteration, I would look at loss containment before tuning entries. A time-based exit, a tighter grid-level drawdown stop, or a rule that prevents one position from destroying the whole day may matter more than trying to improve the already high hit rate.

MLScore GF-T4 GB

MLScore GF-T4 GB ended at +189 yen.

The trade split was almost too clean: +202 yen and -13 yen. One win, one loss. A 50.0% win rate. And still, this was the best-shaped result of the day.

The payoff ratio was 15.54. That is the number I care about here. The losing trade was kept tiny, while the winning trade had enough room to matter. This is what GateGrid AI did not do today.

The score log supports that reading. A BUY with score 96.43 went through and was executed. Other SELL candidates with scores above 90 were blocked several times. I cannot say every blocked signal would have lost, but I can say the guard was active. It was not blindly following every high score. That is a good sign for live operation, because a score engine without refusal quickly becomes overconfident.

LLMBridgeTrader

LLMBridgeTrader ended at +32 yen on the confirmed result.

It was not a large contribution, but on a day where GateGrid AI lost 304 yen, even +32 yen had a role. This bot is the one where I most want to keep watching the reasoning, not just the trade result.

LLMBridgeTrader is designed to let the AI choose more than BUY, SELL, or NONE. It can decide OPEN, HOLD, CLOSE, REVERSE, and NONE. That means the important question is not only “did it enter correctly?” The better question is “did it know when to stop holding?”

Today’s confirmed +32 yen is small, but the experiment remains valuable. Once the full OPEN / HOLD / CLOSE / REVERSE logs are reviewed trade by trade, the real story will be whether the AI’s exit reason matched the actual price behavior. That part still needs more evidence.

BoundSniper

BoundSniper ended at +86 yen.

BoundSniper is different from the AI-heavy bots. It receives TradingView signals through a webhook and sends the corresponding orders to MT5. Its job is not to predict the market. Its job is to execute the signal path cleanly.

The recent monitor showed OPEN_LONG and CLOSE_LONG events being executed, with Request executed appearing on both order send and position close. That is boring in the best possible way. On a live bot, boring execution is useful.

Today, BoundSniper did not need to be the star. It just had to be different from GateGrid AI, and it was. That +86 yen helped turn a losing single-bot day into a barely positive portfolio day.

Summary

The total was only +3 yen, but the day gave me a clear read. GateGrid AI had the higher win rate and still lost. MLScore GF-T4 GB had the lower win rate and won because the loss stayed small.

The next improvement target is not “more wins.” It is the size of the one bad loss. If GateGrid AI can reduce that -501 yen type of trade, the same 4W / 1L day could look completely different.

Today was not a strong profit day. It was a useful warning disguised as a tiny green number.

Turning Red Days into Training Data: The June 11th AI Bot Test

In today’s episode, we break down the June 11th live test of our four MT5 automated trading bots. The portfolio ended the session with a total realized loss of -1,295 JPY, representing a daily return of about -0.75%. But as we discuss in today’s podcast, in the world of machine learning, a losing day isn’t just a failure—it’s highly valuable, labeled training data.

We dive into the completely different behaviors of each bot to uncover what went wrong and what went right:

* GateGrid AI (GBPUSD): The only profitable bot of the day, securing a clean +279 JPY. It perfectly executed two short trades with zero losses, proving that its strict, multi-layered entry filtering works effectively to capture controlled profits.

* BoundSniper (USDJPY): Finished at -282 JPY. With one win and one loss, it highlighted that while the MT5 execution layer is working, the upstream TradingView signal logic needs a better risk-to-reward balance.

* LLMBridgeTrader (EURUSD): Ended at -283 JPY. Despite maintaining a 50% win rate across six trades, the size of the losses simply outweighed the wins. It clearly showed that while the AI can make winning decisions, its overall expectancy and risk-reward structure still require adjustment.

* MLScore GF-T4 (GBPJPY): Took the hardest hit of the day at -1,009 JPY from two stopped-out trades. However, this provided the clearest and most valuable learning sample for our machine learning model. These clean losing patterns are exactly the feedback the model needs to analyze what market structures failed and improve its future predictions.

The ultimate goal of this project isn’t to perfectly avoid losing days—that is impossible. The real goal is to build automated systems that record, analyze, and learn from them. Join us as we explore how we use a “data-rich” red day to build smarter trading bots!

#FX #MT5 #AITrading #MachineLearning #AlgorithmicTrading #SystemTrading

In today’s episode, we break down the June 10th parallel test of our four MT5 automated trading bots. The total realized profit for the day was a modest +333 JPY, representing a +0.19% return on the portfolio. While it wasn’t a massive windfall, this session perfectly demonstrated a vital concept: the power of diversification.

We dive into the performance of each bot to see how portfolio structure mattered more than individual bot performance:

* GateGrid AI (GBPUSD): The only losing bot today, finishing at -153 JPY. It opened positions on both the buy and sell sides but was caught in a difficult zone without enough follow-through, signaling a need to review its dual-position exit logic.

* BoundSniper (USDJPY): The most stable performer of the day. Acting as a pure execution bot, it closed three clean, winning trades for +172 JPY. It proved that sometimes simple, rule-based execution beats complex AI planning.

* LLMBridgeTrader (EURUSD): Delivered the highest absolute profit of +182 JPY. It caught several great trades, but a late -193 JPY loss reduced its earlier gains, highlighting the need for stronger “daily profit protection” rules once a target is reached.

* GBPJPY Bot: Added a +132 JPY profit to the portfolio. While it was only a single closing transaction, it perfectly executed its role by helping offset the losses from GateGrid AI.

The biggest lesson from today’s session? One bot lost, but the portfolio still won. By running completely different logics—rule-based execution, AI-driven trade planning, and machine-learning grid filters—across multiple currency pairs, we absorbed individual weaknesses and maintained a positive balance.

Join us as we discuss why a controlled, diversified green day is the ultimate goal for a live automated trading system!

#FX #MT5 #AITrading #AlgorithmicTrading #Diversification #RiskManagement

In today’s episode, we break down the June 9th parallel test of our four MT5 automated trading bots. The portfolio ended the session with a combined realized loss of -1,432 JPY. At first glance, it looks like a simple losing day, but the detailed results revealed exactly what we need to do next to improve our systems.

We dive into the distinct performances of each bot to uncover why live data is far more valuable than historical optimization:

* GateGrid AI (GBPUSD): The main source of today’s deficit, suffering a -1,602 JPY loss on a single trade. This taught us a critical lesson: actual execution quality—such as spreads, volatility, and LLM judgment delays—can drastically alter real-world outcomes. Moving forward, we are running this bot at 0.01 lot to measure its true Expected Value (EV) in live conditions for the next few weeks.

* BoundSniper (USDJPY): Finished at -278 JPY. Despite maintaining a good win rate with two winners and one loser, the single losing trade wiped out the gains. It serves as a textbook example of why win rate alone isn’t enough, highlighting the urgent need to rebalance its payoff ratio and exit rules.

* LLMBridgeTrader (EURUSD): Ended almost perfectly flat at -6 JPY when factoring in unrealized profits. It effectively avoided large losses, suggesting that its AI-driven position management for holding and closing trades is functioning as a solid defensive mechanism.

* MLScore GF-T4 GB (GBPJPY): The undisputed MVP of the day, securing a solid +496 JPY realized profit and reaching +615 JPY with open positions included. It successfully capitalized on the high volatility of GBPJPY, effectively carrying the weight of the entire portfolio today.

The ultimate takeaway from today’s session is that while past optimization shows what worked historically, live trading shows what is working right now. Today’s loss was not just a loss—it was highly valuable data.

Join us as we discuss our strategic pivot toward live EV measurement and how we use red days to build smarter bots!

#FX #MT5 #AITrading #AlgorithmicTrading #MachineLearning #SystemTrading

In today’s episode, we break down the June 8th parallel test of our four MT5 automated trading bots. The portfolio ended the day with a solid realized profit of +1,189 JPY. But the real success story wasn’t just about the money we made—it was about the money we didn’t lose, thanks to our newly implemented safety layers.

We dive into the performance of each bot to see how they executed their distinct roles perfectly:

* GateGrid AI (GBPUSD): The top earner of the day, securing +643 JPY. It executed two highly efficient, short-term trades and closed them quickly in profit, leaving no open exposure.

* BoundSniper (USDJPY): Finished at +294 JPY. It perfectly demonstrated the resilience of rule-based execution, absorbing two tiny initial losses (-4 JPY each) before catching three solid profitable exits.

* MLScore GF-T4 (GBPJPY): Secured a +252 JPY realized profit on a short trade while holding only a microscopic -7 JPY open drawdown.

* LLMBridgeTrader (EURUSD): The most important bot of the day—because it didn’t trade at all. While the LLM generated three “BUY” signals, our newly built Machine Learning (ML) safety gate blocked every single one of them due to candidate and direction mismatches.

The ultimate lesson from today’s session is simple: in automated trading, a blocked trade can be just as valuable as a winning trade. Our portfolio won today not by being aggressive, but by letting each bot do its job and allowing the ML gate to say “no” when confirmation was missing.

Join us as we discuss how giving our AI bots the power to hit the brakes is taking our system stability to the next level!

#FX #MT5 #AITrading #MachineLearning #AlgorithmicTrading #RiskManagement

In today’s episode, we review the weekly performance of our four MT5 automated trading bots from June 1 to June 5. The portfolio ended the week with a combined realized loss of -3,307 JPY. While it wasn’t a profitable week financially, it was arguably our most valuable week for system development.

We break down each bot’s behavior to understand why giving AI complete autonomy is a risky game, and why the ultimate feature of a trading bot is a reliable “brake”:

* GateGrid AI: The clear winner of the week, finishing at +707 JPY. Its multi-layered filtering system proved that a bot’s true power lies not only in finding entries, but in its ability to say “do nothing” and avoid bad trades.

* BoundSniper: Finished at -868 JPY. As a pure execution bot, its losses confirmed that the MT5 execution layer is doing its job, but the upstream TradingView signal logic needs serious refinement and better filtering.

* LLMBridgeTrader: Took a hard hit at -1,399 JPY. It clearly demonstrated that giving an AI full autonomy over position management (OPEN, HOLD, CLOSE, REVERSE) is dangerous without a strict “ML gate” to reject weak trading plans before they reach the market.

* MLScore GF-T4: Ended at -1,747 JPY. It exposed a critical structural flaw: re-entering the market under the same unfavorable conditions immediately after a stop-loss. It highlighted the urgent need for re-entry logic, cooldown rules, and daily risk limits.

The biggest takeaway from this week? AI can create brilliant trading plans, but the system still needs the final authority to hit the brakes. Join us as we discuss how we are using this week’s “valuable losses” as direct training and debugging data to build smarter, safer trading systems!

#FX #MT5 #AITrading #AlgorithmicTrading #MachineLearning #SystemTrading