Podcast
AI FX Bot Lab: Real Trading Experiments
Hosted by Kimi | Japan FX Bot Lab · EN
Can AI really trade forex?
AI FX Bot Lab is a real-time experiment from Japan, where I build and test AI-assisted FX trading bots using MT5, Python, machine learning, and local LLM tools. I share live results, failures, risk lessons, and bot improvements from rule-based, AI-driven, and ML + LLM hybrid systems. Not financial advice.
fxaibotlab.substack.com
fxaibotlab.substack.com
58episodes
Episodes
Newest firstAll episodes
A 59% Win Rate Still Lost Money: GateGrid’s Exit Math Was the Problem
6d ago00:01:49Tap to summarizeBottom LineThe six-bot portfolio closed August 11 at -¥55, with 32 wins and 22 losses. A 59.3% win rate does not look bad on its own. The uncomfortable number was the 0.66 payoff ratio: the average winner was about ¥36, while the average loser was ¥55.GateGrid AI made the problem easiest to see. It won 23 of 43 closed trades and still lost ¥295 because its average loss was much larger than its average win. The -¥156 largest loss made me stop for a second. This was not a day where entry accuracy completely failed; the damage came from what happened after positions were already open.Results by Bot■ BoundSniper Bot +¥89Record: 3W / 0L (Win rate 100.0%)Gross profit: +¥89Gross loss: ¥0Payoff ratio: N/A (no losing trades)Max loss: ¥0■ LLMBridgeTrader ¥0Record: 0W / 0L (Win rate N/A)Gross profit: ¥0Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0■ GateGrid AI -¥295Record: 23W / 20L (Win rate 53.5%)Gross profit: +¥777Gross loss: -¥1,072Payoff ratio: 0.63Max loss: -¥156■ ML_ScoreAnalyst ¥0Record: 0W / 0L (Win rate N/A)Gross profit: ¥0Gross loss: ¥0Payoff ratio: N/AMax loss: ¥0■ MAribbonTrader +¥86Record: 4W / 2L (Win rate 66.7%)Gross profit: +¥224Gross loss: -¥138Payoff ratio: 0.81Max loss: -¥112■ BoundSniper Bot2 +¥65Record: 2W / 0L (Win rate 100.0%)Gross profit: +¥65Gross loss: ¥0Payoff ratio: N/A (no losing trades)Max loss: ¥0■ Total -¥55Record: 32W / 22L (Win rate 59.3%)Gross profit: +¥1,155Gross loss: -¥1,210Payoff ratio: 0.66Max loss: -¥156Today’s Theme: The Exit Can Undo a Decent Entry RateGateGrid is designed as a multi-stage decision system rather than a simple always-on grid. Its design notes describe a CatBoost gate, local LLM judgment through Ollama, volatility and session filters, and position management. That makes its live result interesting for a reason beyond the ¥295 loss: a system built to filter entries still ended up with an unfavorable payoff structure.The MT5 statement does not include the corresponding AI_SKIP, OLLAMA_HOLD, prompt response, or model reasoning log for each trade, so I cannot say which LLM decision caused a particular loss. What the execution record does show is enough to raise the exit question. GateGrid’s average winning trade was about ¥33.8, while its average losing trade was ¥53.6. With a 0.63 payoff ratio, it would need a win rate around 61% just to offset that asymmetry before other costs. It delivered 53.5%.One cluster was especially ugly. Around 14:25, four positions were closed for -¥8, -¥56, -¥76 and -¥101, a combined -¥241. That is the kind of sequence I want to match against the decision log next: did the model keep the basket alive because its original thesis still looked valid, or did the exit mechanism simply react too late? The statement alone cannot answer that, but it tells me exactly where to look.Bot NotesBoundSniper BotBoundSniper finished 3W / 0L for +¥89. The individual exits were +¥52, +¥22 and +¥15, so there was no single oversized winner carrying the result.This bot does not predict the market itself. TradingView generates the instructions and BoundSniper acts as the execution bridge into MT5, which means I read this result differently from the LLM-driven systems. The statement confirms three profitable completed entry/exit pairs; evaluating signal quality or exit reasoning further would require the TradingView signal log alongside the MT5 fills.For today, the execution result is clean. I would not extrapolate much from three trades, though.LLMBridgeTraderThere was no trade statement for LLMBridgeTrader on August 11, so it is recorded as no trades.This is the bot where the LLM has the broadest decision authority: OPEN, HOLD, CLOSE and REVERSE, along with proposed SL and TP distances. Because no live trades were supplied today, there is no evidence to grade its entry or exit decisions. A zero is not a good day or a bad day here; it is simply no sample.GateGrid AIGateGrid produced 23 wins and 20 losses, yet finished at -¥295. That combination is more useful than a simple losing-day label because it isolates the structural issue.Gross profit reached +¥777, but gross loss expanded to -¥1,072. The payoff ratio was only 0.63, and the largest individual loss was -¥156. Several profitable basket closes show that the strategy can recover mixed positions, but the losing baskets were too expensive when that recovery failed.For an ML-plus-LLM system, this is where I want the next experiment to focus. Entry filters can become more selective, but if HOLD and eventual exit behavior allow average losses to grow faster than average winners, better entries alone may not repair the expectancy. My suspicion is the exit side, although I would want the Ollama decision log before calling that settled.ML_ScoreAnalystNo trade statement was supplied for ML_ScoreAnalyst, so the bot is recorded at ¥0 with no trades.Unlike the LLM bots, ML_ScoreAnalyst uses CatBoost scoring without an LLM layer. That makes it useful as a comparison group when enough live samples accumulate: a relatively deterministic score threshold against systems where language models also interpret context.There is nothing to compare from August 11 itself, so I am leaving the result untouched rather than filling the gap with assumptions.MAribbonTraderMAribbonTrader finished 4W / 2L for +¥86, trading GBPCAD in the supplied statement. Its result was positive, but the shape of the P&L was uneven.The six exits were +¥3, -¥26, +¥2, +¥5, -¥112 and +¥214. That final +¥214 take-profit changed the whole day; without it, the bot would have been at -¥128. Seeing the position finally run that far was encouraging, but it also exposes a dependency I do not want to ignore.The payoff ratio was only 0.81 because several wins were tiny while the two losses averaged ¥69. Still, the 66.7% win rate was high enough to make the combination profitable, and one exit did exactly what a chart-reading system should sometimes do: stay with a move long enough for a large winner to emerge.MAribbonTrader uses Qwen to interpret chart imagery and supporting context such as moving-average structure and higher-timeframe information. The MT5 statement records the result but not the corresponding visual judgment or EXIT explanation. Matching that +¥214 trade and the -¥112 loss back to the stored AI reasoning should be far more valuable than merely celebrating the net +¥86.BoundSniper Bot2BoundSniper Bot2 closed 2W / 0L for +¥65, with winners of +¥44 and +¥21.Like the original BoundSniper, this version is primarily an execution bridge, with a different indicator supplying the TradingView signal. Both variants ended positive on the same day, but the sample is too small to decide which signal source is superior.The useful part is that they give the LLM experiments a simple benchmark: external rule-based signals can be compared with systems where AI has more freedom over entries and exits.Closing ThoughtsA portfolio can post a 59.3% win rate and still lose money. August 11 was a small loss in yen, but a useful live experiment because the reason was visible in the distribution rather than hidden in the final number.The next comparison I care about is not “Can an LLM pick direction better?” It is whether giving the model control over HOLD and EXIT can keep average losses from outrunning average wins. GateGrid made that weakness visible today, while MAribbon showed the opposite possibility with one trade that was allowed to run. That tension is probably more interesting than the -¥55 itself. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
One -¥301 Loss Flipped the Whole Day: Five MT5 Bots Closed at -¥294
1w ago00:01:32Tap to summarizeConclusionThe five-bot book finished August 10 at -¥294, with 11 wins and 13 losses. Gross profit was +¥590 against -¥884 in gross losses, giving the whole group a 45.8% win rate and a 0.79 payoff ratio.But the daily total hides the main story. BoundSniper took one -¥301 loss; remove that single trade from the arithmetic and the book would have ended at +¥7. I stared at that -¥301 longer than I did at the final -¥294, because it says more about the day than the hit rate does.Bot-by-bot resultsThe GateGrid account contains both “GateGrid AI” and “GateGrid v4” execution comments on August 10, so I am treating them as one GateGrid line for this five-bot daily comparison.■ GateGrid AI -132 yenRecord: 6W / 7L (Win rate 46.2%)Gross profit: +143 yenGross loss: -275 yenPayoff ratio: 0.61Max loss: -90 yen■ BoundSniper -315 yenRecord: 2W / 2L (Win rate 50.0%)Gross profit: +33 yenGross loss: -348 yenPayoff ratio: 0.09Max loss: -301 yen■ LLMBridgeTrader -78 yenRecord: 0W / 1L (Win rate 0.0%)Gross profit: 0 yenGross loss: -78 yenPayoff ratio: 0.00Max loss: -78 yen■ ML_ScoreAnalyst +411 yenRecord: 2W / 0L (Win rate 100.0%)Gross profit: +411 yenGross loss: 0 yenPayoff ratio: N/A (no losing trades)Max loss: 0 yen■ MAribbonTrader -180 yenRecord: 1W / 3L (Win rate 25.0%)Gross profit: +3 yenGross loss: -183 yenPayoff ratio: 0.05Max loss: -65 yen■ Total -294 yenRecord: 11W / 13L (Win rate 45.8%)Gross profit: +590 yenGross loss: -884 yenPayoff ratio: 0.79Max loss: -301 yenToday’s theme: exits mattered more than entriesThere is one limitation in today’s material that matters for an LLM trading experiment. The MT5 statement tells me when positions opened and closed, the execution prices, P/L, and comments such as [sl] or [tp], but it does not contain the actual model prompt, confidence score, HOLD/CLOSE reasoning, or the text returned by the LLM.So I can evaluate the behavior of the exits, but I should not invent a story about why the model made them. For LLMBridgeTrader and MAribbonTrader in particular, the next layer of analysis needs the model decision log beside the MT5 execution log. That missing link is becoming part of the experiment itself.GateGrid AI: many small exits, but losses were still heavierGateGrid finished at -132 yen with six winners and seven losers. A 46.2% win rate is not especially alarming on its own, but the 0.61 payoff ratio shows the real problem: the average winner was smaller than the average loser.The morning sequence illustrates it well. Two USDJPY positions closed within seconds for +50 and -21 yen, then a later position produced -90 yen, the largest GateGrid loss of the day. In the v4 portion of the account, several small profits appeared, but the final short basket closed at +20, -67 and -78 yen almost immediately after entry.That last cluster bothers me more than the win rate. The system was capable of cutting positions quickly, yet “quick” did not automatically mean “cheap”; the losing legs were still large enough to erase several earlier winners. The exit mechanism is active, but the payoff distribution says it is not balanced yet.BoundSniper: 50% wins and a 0.09 payoff ratioBoundSniper is not an LLM trader. It is an execution bridge for TradingView signals, so there is no reason to blame an AI model for the direction of these trades.Still, its numbers are the clearest warning of the day. It went 2W / 2L, which looks harmless at first glance, but gross profit was only +33 yen against -348 yen of gross losses. The payoff ratio fell to 0.09.One position closed for -301 yen, while the two winners were only +10 and +23 yen. The first daily close also realized -47 yen after including the -19 yen swap. This is exactly why I do not want to judge an automated system by win rate alone: a 50% hit rate can still leave a deeply asymmetric loss profile.For BoundSniper, the question is less about prediction and more about what the TradingView strategy permits before an exit arrives. The bridge did its job; the loss budget around the signal logic needs the attention.LLMBridgeTrader: one trade, and the exit log mattersLLMBridgeTrader had one EURUSD trade. It sold at 1.15479 at 16:45:14 and closed at 1.15528 at 17:30:05, ending at -78 yen.That is roughly 4.9 pips against the short over about 45 minutes. The loss itself is small enough to be controlled, but one trade tells me almost nothing about entry quality.What I do want to know is what happened during those 45 minutes. LLMBridgeTrader is designed to choose among OPEN, HOLD, CLOSE and REVERSE, so the interesting data is whether the model kept returning HOLD while the trade deteriorated, switched to CLOSE at the right moment, or was closed by another safety condition. The MT5 statement alone does not answer that, and I would rather leave that blank than manufacture a neat explanation.ML_ScoreAnalyst: the best result also had the most interesting exitML_ScoreAnalyst was the only clear winner, finishing at +411 yen from two GBPJPY trades. The first closed at TP for +300 yen.The second is more interesting. It entered long at 213.485 and later closed via an [sl 213.596] execution for +111 yen. Seeing a stop-loss label attached to a profitable trade made me look twice; whatever moved or maintained that stop, the practical result was that the exit protected profit rather than turning the trade back into a loser.There were no losing trades, so the payoff ratio cannot be calculated meaningfully yet. A 100% win rate from two samples also does not prove much, but the exit shape was clean: one target win and one protected-profit stop.MAribbonTrader: the stop worked, then the Bot kept coming backMAribbonTrader traded GBPCAD four times, all from the sell side. The first closed for +3 yen, followed by three losses of -65, -58 and -60 yen.The good part is that the maximum individual loss stayed at -65 yen. The hard exit prevented a BoundSniper-style single loss from appearing. The bad part is the repetition: after being stopped, the Bot returned to essentially the same directional idea several times and accumulated -180 yen.For an LLM chart-reading Bot, this is where EXIT and WAIT need to be considered together. A stop can end one bad trade correctly, but if the model immediately interprets the same market structure as another valid sell, the portfolio-level exit has not really happened. I suspect the improvement belongs somewhere around post-stop regime recognition, although one day is not enough to prove it.Closing thoughtsAugust 10 was not a simple “AI bots lost” day. ML_ScoreAnalyst actually covered a large part of the damage, GateGrid kept most individual losses moderate, and MAribbon’s hard stops did cap each attempt.The uncomfortable number came from somewhere else: loss concentration. One -301 yen trade changed the sign of the entire five-bot book, while another Bot lost through repeated smaller attempts. The next thing I want from these logs is not a prettier win rate; I want to see how each system behaves immediately after the market tells it that its first idea was wrong. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
Don’t Lower Your Standards Just Because the Numbers Are Bad
1w ago00:01:33Tap to summarizeA trader takes two losses and looks for a third trade.A founder sees no sales and cuts the price.A creator sees low engagement and changes the entire content strategy.Doing something feels better than doing nothing.Action creates the feeling that the problem is being handled.But some of our worst decisions begin exactly there.The original result was bad.Then pressure made us lower the standard.The third trade was never part of the planImagine losing twice before lunch.Both trades were valid.Both stops worked as intended.The trading plan says the day is over.But the chart remains open.A new setup appears.On a normal morning, you probably would not take it.Today it looks different.You are already down.You want the day repaired.So “not quite good enough” quietly becomes “good enough.”You enter.Maybe you lose again.The problem is larger than a third loss.Your entry standard changed because your P&L changed.The market did not create a better opportunity.Your need for a better outcome created one.Winning after breaking the rule can be worseSuppose the third trade wins.Now the account looks better.Emotionally, this feels like proof that taking the trade was correct.But another lesson has been learned:The daily stop is flexible.Rules can be ignored when the situation feels special.A bad process produced a good outcome.That is dangerous because markets occasionally reward behavior you should not repeat.The same thing happens in business.No sales? Cut the priceImagine selling a service for $500.A week passes without a sale.Traffic exists.A few people ask questions.Nobody buys.Friday evening arrives and the price becomes $350.Still quiet.Then comes a temporary offer at $250.Maybe someone finally buys.It is tempting to conclude:“The problem was price.”But perhaps the offer was unclear.Perhaps the buyer could not tell who it was for.Perhaps the problem it solved was not painful enough.Perhaps the traffic came from the wrong audience.Lowering price may have changed the outcome without fixing the real problem.And if every difficult sales week leads to another discount, you eventually build a business that only works when your own standards are negotiable.More effort can amplify the wrong thingWhen results disappoint, “do more” sounds practical.More sales calls.More posts.More trades.More hours.Sometimes volume really is the missing ingredient.Ten customer conversations may be too few to learn anything.But if the underlying direction is wrong, more activity can simply create more bad data.An unclear offer sent to 1,000 people is still unclear.A weak trading setup taken ten times is still weak.Content the audience does not need does not become useful because it is published daily.Before increasing volume, ask whether the activity itself still meets the standard.Bad bot performance makes me want to touch everythingI run multiple MT5 trading bots in parallel.Every day produces numbers.Profitable bots.Losing bots.Inactive bots.Occasionally one system has an ugly day.The immediate temptation is modification.Change the stop.Add another filter.Adjust entry logic.Restrict another session.But if I change the system every time it loses, comparison becomes impossible.Tomorrow’s bot is no longer yesterday’s bot.A win three days later tells me very little because several variables changed at once.So I try to ask a different set of questions first.Did the bot enter under the intended conditions?Did the stop behave correctly?Were economic-event restrictions respected?Did execution fail?Was the position limit followed?If the system followed its rules and lost, one loss is not automatically a development task.If it broke its rules and won, the profit does not automatically make the behavior acceptable.Both are surprisingly difficult distinctions to maintain.Rules are not sacredThere is an obvious objection.What if the rule itself is bad?Then it should change.A business with weak positioning needs adjustment.A trading strategy whose edge has disappeared should not be defended out of loyalty.A rule is not valuable because it is old.The real question is when the rule changes.Changing it immediately after emotional pain is very different from changing it after defined evidence.Before the pressure arrives, decide:How much evidence triggers review?Which metrics matter?What specific event requires stopping?What conditions justify a change?That turns adaptation into a process rather than a reaction.Bad days reveal what the standard actually wasRules are easy to respect when things are going well.Profits are coming.Customers are buying.Audience numbers are growing.Pressure is low.The real test arrives when nothing seems to work.That is when exceptions begin.Just this once, widen the stop.Just this week, discount heavily.Just tonight, work until 2 a.m.Just this client, accept work you already decided not to take.Each exception looks small.Repeated often enough, they teach something larger:My own rules disappear when I become uncomfortable.Self-trust is built in boring momentsConfidence is often associated with visible success.Revenue.Profit.Qualifications.Recognition.But self-trust may be built in quieter moments.You stopped trading because the daily limit was reached.You did not accept a price below the floor you had chosen.You took the day off because you had already decided it would be a day off.Nobody applauds those decisions.They barely look like achievements.But you remember them.You also remember the opposite.That is why repeatedly breaking small promises to yourself can matter more than it appears.Standards can also become excusesThere is another trap.“I am following my rules” can become a way to avoid uncomfortable evidence.A product that has not sold for six months deserves review.A trading system that continues to lose over a meaningful sample deserves review.Rules should stabilize decisions, not protect us from reality.That is why review conditions matter.Thirty trades.A defined drawdown.Three repeated execution failures.A specific conversion threshold.Whatever makes sense for the system.The point is to decide the trigger before the emotional moment arrives.Avoid major decisions immediately after bad resultsOne practice I find useful is simple:Do not make a large change immediately after a painful number.A large trading loss.A zero-sales week.A failed launch.A post that goes nowhere.Write down what happened.Identify the possible cause.Then revisit the decision later.A surprising number of urgent changes feel less urgent the next morning.You cannot control every numberMarkets move without permission.Customers can say no.Readers can ignore an article.Applications can be rejected.Those outcomes are only partly under our control.But other things are.Where the stop goes.The lowest acceptable price.The type of work you will refuse.The hour when work ends.The conditions required before taking another trade.Bad numbers do not require those standards to become bad too.The next time the result disappoints you, notice what you suddenly want to do.That impulse may tell you which rule needs to be written before the next difficult day arrives. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
[AI Trading Log] Whispering Winners, Loud Losers
2w ago00:01:49Tap to summarizeOn August 5 and 6, 2026, we ran a parallel test of six MT5 automated trading bots. The results across these two days provided the ultimate case study in why exit discipline—rather than entry prediction—dictates the survival of an automated trading portfolio.When our losses were allowed to speak at full volume, we lost money despite a solid win rate; when we kept our losses quiet, even a modest day turned into a major victory.Overall Performance: A Tale of Two Distribution Shapes* August 5: Total -¥478 (61.5% Win Rate) The fleet closed 15 trades with 8 wins, 5 losses, and 2 flat exits. On paper, a 61.5% win rate (excluding flats) is respectable. However, the underlying shape of the distribution was highly fragile: the average winner was only about ¥55, while the average loser was nearly ¥188, dropping the combined payoff ratio to a dismal 0.29. We had to win more than three times just to offset a single average loss.* August 6: Total +¥634 (66.7% Win Rate) On August 6, the win rate was structurally similar at 66.7% (6 wins, 3 losses). But this time, the payoff ratio shifted to a healthy 3.10. The portfolio generated ¥756 in gross profits against only ¥122 in gross losses, with the maximum closed loss strictly capped at ¥88. This healthy asymmetric profile allowed our winners to actually matter.Bot-by-Bot Breakdown: Exit Anatomy1. ML_ScoreAnalyst (GBPJPY Breakout / CatBoost Evaluation)* August 5: -¥489 (0W / 2L)* August 6: +¥326 (1W / 0L)* This bot experienced the most dramatic swing. On August 5, it dragged the portfolio down by hitting two nearly identical stop losses of -¥252 and -¥251 (buffered slightly by +¥14 in swap). These repeated stop sizes functioned as an oversized loss unit that required five average winners from the group to recover. On August 6, however, it took a single long trade on GBPJPY (entered at 212.726, exited at 213.052), hit its take-profit (TP) cleanly, and finished as the day’s top performer with +¥326. It is a stark reminder that a lighter, non-LLM architecture can produce brilliant results, provided the expected upside justifies the risk.2. GateGrid AI (EURUSD ML + LLM Hybrid)* August 5: -¥148 (1W / 1L / 1 Flat)* August 6: +¥91 (2W / 1L)* GateGrid’s advanced multi-gate entry system (CatBoost, Ollama, volatility checks) successfully filters out weak entry setups. But on August 5, a single -¥238 short-position loss completely erased its ¥90 winner, highlighting its vulnerability to a low payoff ratio (0.38). On August 6, the bot redeemed itself by capping its single losing exit at just -¥9, allowing two small winners (+¥97 and +¥3) to carry the basket to a +¥91 finish. Keeping the losing leg from becoming the “story of the day” is exactly how this grid strategy is supposed to operate.3. LLMBridgeTrader (EURUSD Autopilot AI)* August 5: +¥126 (1W / 0L)* August 6: +¥201 (2W / 2L)* LLMBridgeTrader is allowed to fully direct its positions (OPEN, HOLD, CLOSE, REVERSE). On August 5, it showed off a highly sophisticated exit by sliding its stop loss below its EURUSD short entry price, securing +¥126 via a profit-protecting stop. On August 6, it achieved a +¥201 realized profit. Despite a flat 50% win rate, its average winner was far larger than its average loser (payoff ratio of 2.78). However, it carried -¥89 in unrealized losses on an open EURUSD short at the reporting cutoff, which remains the key position to monitor.4. BoundSniper Bot (USDJPY TV Signal Relay)* August 5: +¥25 (3W / 0L)* August 6: +¥16 (1W / 0L)* This bot does not generate its own market predictions; it simply transfers TradingView webhooks into MT5 executions. It performed its job flawlessly on both days, capturing small, clean wins. While the absence of losses is excellent, capturing only a few yen per trade leaves the strategy highly sensitive to spreads and execution slippage.5. bound_sniper 2 (Second TV Relay)* August 5: +¥23 (1W / 0L)* August 6: No trades.* Our newest sixth bot entered a quick USDJPY long on August 5, exiting in under two minutes for a clean +¥23 profit. It sat out of the market on August 6.6. MAribbonTrader (Visual LLM Chart-Reader)* August 5: -¥15 (2W / 2L / 1 Flat)* August 6: No trades.* This visual bot uses a local LLM to read screenshots of MT5 charts. On August 5, its stop mechanism successfully protected several trades (producing a decent payoff ratio of 0.88 and containing losses under -¥113). However, its high trading frequency—entering four new long positions in a tight window—suggests it may have been repeatedly buying into a fading trend. It remained inactive on August 6.Key Takeaway: Taming the Volume of Our LosersThe contrast between these two sessions proves that our entry models are generally succeeding at finding correct directions. Our struggle is managing what happens when an idea stops working. On August 5, our winners whispered while our losers spoke at full volume. On August 6, we managed to mute the losers, allowing the winners to carry the day.Moving forward, our priority is not adding more entry filters. We must focus on tightening our exit rules: establishing clearer abandonment thresholds for GateGrid AI, auditing the risk-to-reward ratio on ML_ScoreAnalyst’s stops, and analyzing the decision logs of our LLM bots to ensure “HOLD” states are backed by genuine logic rather than hesitation.I can compile these August 5–6 metrics into a visual comparison table to help you analyze the exact shift in payoff ratios across all six bots. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
Ten Wins Still Ended Negative: Five MT5 Bots Exposed an Exit Problem
2w ago00:19:52Tap to summarizeThe five bots closed 13 trades on August 4 and won 10 of them. That sounds like a strong session, but the realized result was negative 16 yen after swap.The problem was not a lack of winning trades. It was the size and shape of the losses. The average winner was 62.6 yen, while the average loser was 208 yen, leaving the combined payoff ratio at only 0.30.BoundSniper Bot won four of five closed trades, yet one 263-yen loss and 18 yen of negative swap erased all four small wins. ML_ScoreAnalyst produced a 303-yen winner and a 304-yen loser, almost a perfect cancellation. I had to look at those two numbers twice.The MT5 reports also showed two positions still open at the end of the day. ML_ScoreAnalyst carried a 90-yen floating loss, and MAribbonTrader carried a 111-yen floating loss. The realized result was close to flat, but the risk had not disappeared.Bot-by-Bot Results■ GateGrid AI +99 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +99 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yenOpen P/L: 0 yen■ BoundSniper Bot -225 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +56 yenGross loss: -263 yenSwap: -18 yenPayoff ratio: 0.05Max loss: -263 yenOpen P/L: 0 yen■ LLMBridgeTrader +61 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +118 yenGross loss: -57 yenPayoff ratio: 1.04Max loss: -57 yenOpen P/L: 0 yen■ ML_ScoreAnalyst -1 yenRecord: 1W / 1LWin rate: 50.0%Gross profit: +303 yenGross loss: -304 yenPayoff ratio: 1.00Max loss: -304 yenOpen P/L: -90 yen■ MAribbonTrader +50 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +50 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yenOpen P/L: -111 yen■ Total -16 yenRecord: 10W / 3LWin rate: 76.9%Gross profit: +626 yenGross loss: -624 yenSwap: -18 yenPayoff ratio: 0.30Max loss: -304 yenOpen P/L: -201 yenThe gross trading result before swap was positive by only 2 yen. Once the 18-yen swap was included, the realized result became negative 16 yen.Today’s Theme: A High Win Rate Can Hide Weak ExitsThe day was a clean example of why I do not want to rank these bots by win rate alone. Ten winners looked reassuring, but most of them were too small to absorb the three losing trades.This matters even more for bots that let an LLM decide whether to HOLD, CLOSE, or REVERSE. An entry can be reasonable and still become a poor trade if the model keeps defending the position for too long. The useful question is not only whether the model predicted the direction correctly, but whether it stopped believing its own thesis at the right moment.The MT5 report tells me when and where a trade was closed. It does not contain the full AI response, confidence score, chart interpretation, or exit reason. To evaluate the LLM layer properly, each deal now needs to be joined with the model log that produced OPEN, HOLD, CLOSE, REVERSE, WAIT, or EXIT.GateGrid AI: Clean Realized Result, but the Exit Reason Is MissingGateGrid AI finished with two winners worth 99 yen in total and no open position. Six earlier pending orders were canceled before two buy-stop orders were eventually filled, so the order-management layer did not simply leave old entries sitting in the market.The first position was opened at 14:44 and the second at 17:08. Both were closed by market orders around 17:12, producing 91 yen and 8 yen. Closing the two grid legs together left the account flat, which is the result I want to see from a strategy that manages positions as a group.Still, the report does not show whether the close came from trailing logic, a local Ollama decision, a grid-level target, or another rule. A profitable exit is welcome, but one two-trade sample does not tell me whether the exit manager is improving. The next step is to match the close timestamp with the CatBoost score, ATR state, session gate, Ollama response, and recorded exit trigger.BoundSniper Bot: Four Wins Could Not Repair One Old LossBoundSniper Bot posted four winners after its first closing trade, but those wins were only 31, 8, 10, and 7 yen. Together they earned 56 yen. The earlier loss was 263 yen, with another 18 yen charged as swap.That single exit made the whole day negative 225 yen. Seeing a payoff ratio of 0.05 made me pause; the bot could repeat this exact 80% win rate and still lose money.BoundSniper itself does not predict the market. It receives TradingView signals through the webhook pipeline and executes them in MT5. The issue therefore appears less like an MT5 execution problem and more like an exit problem in the upstream TradingView strategy, or in the management of a position carried from the previous session.The losing position was closed at 01:02, while no corresponding same-day entry appears in the report. That suggests it was already open before August 4. I cannot determine from this report whether the exit was late, but the negative swap and oversized loss make the inherited-position logic worth reviewing.LLMBridgeTrader: The Most Balanced Exit Profile of the DayLLMBridgeTrader closed three EURUSD trades for a net gain of 61 yen. Its two winners totaled 118 yen, while its single loss was 57 yen, producing a payoff ratio of 1.04.The first short was closed by a stop order for a 93-yen profit. After that, two long positions were opened and closed within about 15 minutes, one for a 57-yen loss and one for a 25-yen gain. The loss was contained rather than allowed to grow into the largest loss of the session.This was the best balance between winning and losing size among the bots that recorded both outcomes. The numbers do not prove that the LLM made good discretionary decisions, though. The MT5 report does not reveal whether those exits were CLOSE responses, fixed safety rules, stop movement, or scheduled reevaluations.Because LLMBridgeTrader can choose OPEN, HOLD, CLOSE, and REVERSE, its real experiment is the change of mind. The valuable log is the moment when confidence weakens enough to replace HOLD with CLOSE. Today’s trade sizes look reasonable, but I still need the decision trace before giving the model credit.ML_ScoreAnalyst: One Winner, One Loser, and No Edge Left OverML_ScoreAnalyst earned 303 yen on its first GBPJPY trade and lost 304 yen on the next. The realized result was negative 1 yen, almost a numerical draw, while a third long position remained open with a 90-yen floating loss.The 304-yen stop was the largest closed loss across the five bots. It canceled a trade that had been held for several hours and reached a similarly sized profit. Again, almost the same amount in both directions — not disastrous, but not much of an edge either.This bot uses CatBoost to score entries rather than an LLM to interpret chart context. Its entry model may still have selected valid breakout candidates, but the day shows that entry scoring alone cannot create positive expectancy when the exit distribution is symmetrical.The open third trade also means the day cannot be evaluated only from the negative 1-yen realized result. The next useful comparison is the entry score of the 303-yen winner, the 304-yen loser, and the still-open trade. If the scores were similar, the model may not be separating strong and weak setups yet.MAribbonTrader: A Good Protective Exit Followed by a Difficult Re-entryMAribbonTrader closed one GBPCAD long for a 50-yen gain. The position was exited through a stop above the entry price, which looks like a protective stop that had already locked in profit.About ten minutes later, the bot opened another long. That second position ended the reporting period with a 111-yen floating loss. The realized exit was good, but the immediate return to the same direction is the part I want to inspect.MAribbonTrader sends chart images, moving-average ribbons, higher-timeframe context, support and resistance information, ranges, and channel structure to Qwen. The model is supposed to distinguish a fresh setup from a chart that only resembles the previous one.The open question in the log is whether the second BUY came from genuinely renewed evidence or from a bullish interpretation that never really changed. The first trade shows that EXIT can protect profit. The second entry will test whether WAIT is strong enough after that exit.ClosingThe five bots did not have a bad day in the usual sense. Three finished with positive realized results, one was almost flat, and only BoundSniper Bot recorded a clear realized loss.Yet the fleet still finished negative because the losing trades were allowed to carry much more weight than most of the winners. A 76.9% win rate did not rescue a 0.30 payoff ratio.For the next review, I care less about adding another entry filter. I want the decision logs around the three losing exits, the BoundSniper position carried into the day, and MAribbonTrader’s quick re-entry. The bots are finding winners. I am not convinced they all know when their idea has expired.② Substack NoteFive MT5 bots closed 13 trades on August 4.The record was 10 wins and 3 losses, but the realized result was still -16 yen. BoundSniper won four times, yet one larger loss erased them. ML_ScoreAnalyst made +303 yen and then lost 304 yen.The fleet’s win rate was 76.9%. Its payoff ratio was only 0.30.The entries were not the main problem today. The exits were. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
[AI Trading Log] Exits Made the Difference: Five-Bot Portfolio Covers Each Other’s Weaknesses (July 30 to July 31)
2w ago00:01:50Tap to summarizeHello! I have been running a parallel test of five distinct MT5 automated trading bots to evaluate their real-world behaviors. For the two days of July 30 and 31, the bots successfully covered each other’s weaknesses, resulting in two consecutive days of positive returns. However, looking closely at the data reveals a stark contrast between successful exits and remaining challenges.July 30 Overall Performance: GateGrid AI Dominates with Tiny LossesOn July 30, the portfolio finished with a total profit of 592 yen. The star of the day was GateGrid AI. Alongside a high win rate of 12 wins and 2 losses, the combined losses of the two losing trades were kept to a mere 9 yen, with a maximum loss of 7 yen. With an average win of 68.5 yen and an average loss of 4.5 yen, it achieved an incredible payoff ratio of 15.22, earning 813 yen on its own. Meanwhile, ML_ScoreAnalyst closed a carried position from the previous day for a 215 yen loss, but GateGrid AI’s profits completely covered it. This day proved the strength of admitting defeat quickly and cutting losses.July 31 Overall Performance: Saved by Two Take-Profits Amidst Recurring Exit IssuesOn July 31, the portfolio managed a narrow positive finish of 189 yen. However, the leading bots completely swapped. ML_ScoreAnalyst successfully executed two clean take-profits to earn 593 yen, and BoundSniper Bot added 405 yen through a run of short entries. Their profits were absolutely necessary because yesterday’s hero, GateGrid AI, recorded a massive loss of 843 yen. During a multiple-position unwinding process, GateGrid AI allowed a large loss, dragging down the overall performance. Without ML_ScoreAnalyst, the day would have ended at minus 404 yen.Bot-by-Bot Analysis1. GateGrid AIWhile it can keep losses extremely small as seen on July 30, it still has a weakness of realizing large losses, such as a 451 yen loss on July 31, when unwinding multiple positions. Since its entry accuracy is not bad, the decision-making process for transitioning from holding to closing is the primary challenge.2. BoundSniper BotIt had no submitted trades on July 30, but made a 405 yen profit with a 68.8 percent win rate on July 31. However, it also took a 399 yen loss in just 43 seconds. The structure of stacking small wins only to be heavily reduced by a single loss still exists, suggesting the need for an independent emergency loss limit rule as an execution relay.3. ML_ScoreAnalystIt saved the entire portfolio on July 31 with two clean take-profits totaling 593 yen. Because its targets are clearly defined, its results are very easy to audit. However, as seen with the 215 yen loss on July 30 from a carried position, it is still necessary to accumulate more data on its losing patterns.4. LLMBridgeTraderIt had no submitted trades on July 30. On July 31, it recorded 1 win and 1 loss for a 34 yen profit. It demonstrated a smart move by shifting the stop loss above the entry price to protect the gains of a profitable position.5. MAribbonTraderIt had no realized profits on either day, only recording a minor 6 yen loss in about 14 minutes on July 30. Although it is a highly discretionary bot, it deserves credit for keeping the loss small and exiting early.Summary: Diversification Effects and Remaining Exit ChallengesOver these two days, the portfolio’s diversification effect worked beautifully, with bots covering for each other’s poor performances to secure consecutive winning days. However, the overall payoff ratio on July 31 remained at 0.65, meaning the fundamental risk of average losses exceeding average wins is still unresolved. The success of automated trading depends not on the entries, but on exit discipline—how cheaply the system can admit defeat. I will continue to verify the systems by focusing on the exit data. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
[AI Trading Log] Surviving FOMC and the Trap of High Win Rates:
3w ago00:01:37Tap to summarizeHello! I have been running a parallel test of five distinct MT5 automated trading bots to evaluate their real-world behaviors and AI decision-making processes. July 28 and 29 provided incredibly insightful data for the portfolio. On July 29, I deliberately left all five bots running through the highly volatile FOMC event instead of shutting them down. The data from these two days delivered a harsh reality check: Event risks like the FOMC do not blow up accounts; ordinary, poorly designed exits and payoff asymmetry are what truly destroy a portfolio.Overall Performance: A 64 percent Win Rate Cannot Outrun Bad ExitsLooking purely at the win rates, the portfolio seemed highly capable of predicting market direction. However, both days resulted in net realized losses.July 28: Total minus 64 JPY (Win Rate 63.6 percent)The fleet closed 7 winning trades and 4 losing trades, ending the day with a realized loss of 64 JPY. The root cause was glaringly obvious: the average winner brought in about 80.4 JPY, while the average loser wiped out 156.8 JPY. The AI successfully called the direction, but it paid far too much when those ideas were wrong.July 29 (FOMC): Total minus 333 JPY (Win Rate 64.3 percent)Despite the FOMC volatility, the damage remained contained with no single closed trade losing more than 314 JPY. The portfolio achieved 18 wins and 10 losses, yet the payoff ratio was a dismal 0.45. The average winner was about 78 JPY, while the average loser reached roughly 174 JPY. FOMC did not create an uncontrolled failure; it was the ordinary exit asymmetry that did most of the damage.Bot-by-Bot Breakdown: Different Brains, Same Exit StrugglesBecause each bot processes information and makes decisions differently, their results and failure points varied drastically.1. BoundSniper Bot: The Disciplined Execution LayerThis bot relays TradingView signals into MT5 and does not predict the market itself. It had no trades on July 28. On July 29, it was the undisputed MVP of the FOMC session, closing 7 wins and 1 loss for a profit of 284 JPY. It posted an incredible payoff ratio of 3.52, proving that fast, externally defined exits can keep risk incredibly small, even during severe market events.2. LLMBridgeTrader: The AI Planner’s HesitationThis AI operates with high autonomy, deciding whether to OPEN, HOLD, CLOSE, or REVERSE a position. On July 28, it closed flat at 0 JPY realized, though it carried an unrealized loss. On July 29, it secured a 105 JPY profit. It successfully protected several winners through stop-based exits, but it also hesitated on holding positions, resulting in late exits and large losses like a 295 JPY loss on July 28 and a 199 JPY loss on July 29.3. GateGrid AI: Small Wins Swallowed by Heavy ExitsThis hybrid bot uses a CatBoost probability gate and an Ollama review to filter entries. It fell victim to the classic “small win, massive loss” trap. On July 28, it lost 65 JPY, as four wins were wiped out by a single 252 JPY loss. On July 29, it lost 259 JPY with a terrible 0.42 payoff ratio. It proved that entry filtering alone cannot repair a fundamentally flawed exit profile.4. ML_ScoreAnalyst: Improving Risk-to-Reward BalanceThis fast bot evaluates confirmed GBPJPY breakouts using a CatBoost score. It had no trades on July 28. On July 29, it lost 69 JPY. Among the losing bots, it came the closest to a balanced risk-to-reward profile with a payoff ratio of 0.88, though its stops were still slightly heavier than its target profits.5. MAribbonTrader: Rich Context, Weakest PayoffsA chart-reading AI that sends MT5 screenshots and rich visual context to a local LLM for discretionary analysis. It won 1 JPY on July 28. On July 29, it lost 394 JPY. Despite receiving the richest visual context of all five bots, it exposed the weakest payoff structure at 0.12. A 60 percent win rate was useless when the average winner of 30 JPY was forced to absorb an average loss of 242 JPY. It highlighted that giving an AI more information does not automatically produce a better exit.Conclusion: The Flaw is Inside the System, Not the EventThe ultimate takeaway from these two days is that the systems were not defeated by a lack of winning trades or by market events. They were defeated by the massive distance between their normal profits and normal losses. The most critical part of an experimental trading model is the brief window of time between the setup weakening and the actual closure of the position. Moving forward, the primary focus must shift away from entry accuracy and prioritize strict exit discipline, ensuring the AI learns how to quickly and cheaply abandon bad ideas. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
The Exit Layer Won: Five MT5 Bots Closed at +¥624
3w ago00:01:42Tap to summarizeConclusionThe five-bot portfolio finished the session with a realized gain of ¥624. Three bots were positive, one did not trade, and LLMBridgeTrader closed four positions without a single win.The -¥195 stop on its first trade made me pause. The later losses shrank to -¥80, -¥16, and -¥5, so the bot did become quicker about getting out, but it never found a profitable exit during the reporting window. That makes this less of an entry contest and more of a test of when each system gives up on its original idea.MAribbonTrader also needs a closer look despite ending positive. Its +¥316 closing trade appears to have come from a position carried into the day, and the three positions opened and closed on July 27 produced a combined -¥89 before swap. The account made money, but the fresh setups did not.Win rate below includes the zero-yen GateGrid AI closure in the total number of closed trades. Gross profit, gross loss, and payoff ratio exclude swap.Bot-by-bot results■ GateGrid AI +384 yen Market: EURUSD- Record: 5W / 0L / 1 flat Win rate: 83.3% Gross profit: +384 yen Gross loss: 0 yen Payoff ratio: N/A, no losing trade Max loss: 0 yen■ BoundSniper Bot 0 yen Trades: None reported Record: N/A Win rate: N/A Gross profit: 0 yen Gross loss: 0 yen Payoff ratio: N/A Max loss: N/A■ LLMBridgeTrader -296 yen Market: EURUSD- Record: 0W / 4L Win rate: 0.0% Gross profit: 0 yen Gross loss: -296 yen Payoff ratio: N/A, no winning trade Max loss: -195 yen Unrealized P/L at cutoff: -16 yen■ ML_ScoreAnalyst +300 yen Market: GBPJPY- Record: 1W / 0L Win rate: 100.0% Gross profit: +300 yen Gross loss: 0 yen Payoff ratio: N/A, no losing trade Max loss: 0 yen■ MAribbonTrader +236 yen Market: GBPCAD- Record: 2W / 2L Win rate: 50.0% Gross profit: +505 yen Gross loss: -278 yen Payoff ratio: 1.82 Max loss: -154 yen Swap: +9 yen■ Total +624 yen Record: 8W / 6L / 1 flat Win rate: 53.3% Gross profit: +1,189 yen Gross loss: -574 yen Payoff ratio: 1.55 Max loss: -195 yen Swap: +9 yen Unrealized P/L at cutoff: -16 yenToday’s theme: the MT5 report knows what happened, but not whyThe execution report gives a clear sequence of entries, exits, stops, and take-profits. What it does not contain is the model context behind those actions: confidence, setup type, HOLD or CLOSE reasoning, chart state, or the inputs shown to the LLM.That gap matters most for LLMBridgeTrader. Its design allows the model to choose OPEN, HOLD, CLOSE, and REVERSE while also proposing SL and TP distances. Looking only at the MT5 result, I cannot tell whether the -¥80 market exit was a sensible early escape from a broken setup or a late reaction after the model ignored an earlier warning.The same issue exists in MAribbonTrader. The trading report shows the outcome, but not whether Qwen saw a first pullback to the long-term ribbon, a resistance retest, a narrowing channel, or a reason to switch from HOLD to EXIT. Without that join, a winning trade can look smarter than it was, and a losing trade can look worse than the decision that produced it.GateGrid AIGateGrid AI had the cleanest realized record of the day. It closed six short positions for five gains and one flat result, with no losing exit and no open exposure at the cutoff.The closures came in groups. Two positions were closed around 14:30 for +¥92 and ¥0, while another pair was closed around 16:58 for +¥110 and +¥21. That looks like basket-level management rather than demanding that every grid layer reach an individual target, and it worked well in this session.There is one configuration detail worth checking. The bot overview describes GateGrid AI as a GBPUSD system, but this live report records EURUSD- orders. The analysis here follows the actual account report, though the symbol difference should be confirmed before comparing the result with model thresholds or training data.A payoff ratio cannot be calculated because there was no losing trade. That is a pleasant problem for one day, but six closures are not enough to judge the grid’s real downside. Its max-loss behavior remains untested in this sample.BoundSniper BotNo BoundSniper transaction details were included, so it is recorded as no trade. For a bridge bot, inactivity is not automatically a problem; it may simply mean TradingView sent no qualifying signal.Still, its logs should distinguish between “no alert received,” “alert rejected,” and “order submission failed.” All three create an empty MT5 report, but they describe very different system states.LLMBridgeTraderLLMBridgeTrader was the weak point of the portfolio. Four completed EURUSD- trades lost -¥195, -¥80, -¥16, and -¥5, producing a 0% win rate and the day’s largest single loss.The sequence is not entirely negative from a risk perspective. After the first stop, each completed loss became smaller, which may indicate that later CLOSE decisions reacted faster. I would not claim that from execution data alone, though; the market may simply have moved less.The first buy was closed by a stop at -¥195. Two later buys were closed at market for -¥80 and -¥16, followed by a sell closed at -¥5. A new short was then opened at 23:00 and remained open with -¥16 of unrealized loss at the report cutoff.For a bot with broad LLM discretion, the next useful comparison is not just BUY versus SELL accuracy. Each losing trade should be joined to the model’s confidence, setup label, original SL and TP proposal, every HOLD decision, and the final reason for CLOSE. The exit model is where the evidence is missing.ML_ScoreAnalystML_ScoreAnalyst took one GBPJPY- short and reached its take-profit for +¥300. It was a simple result: one scored entry, one predefined target, and no further exposure.The fixed exit beat the adaptive LLM exits today, but the sample size is one. I would not promote the score threshold or TP setting on this result alone. What it does provide is a useful control case for the more flexible bots: a narrow decision system can be easier to evaluate because the path from signal to result is short.MAribbonTraderMAribbonTrader recorded two wins and two losses, with a payoff ratio of 1.82. That is the strongest measurable payoff ratio among the five bots, since the other profitable systems had no losing trades from which to calculate one.The +¥316 close appears without a corresponding same-day entry and also earned +¥9 in swap, so it was probably a position carried into July 27. After that, the bot closed a fresh long for +¥189, then lost -¥154 and -¥124 on two more longs. Those three same-day round trips netted -¥89.This split matters. The account-level result was +¥236, but the new setups had a difficult day. The -¥154 stop caught my eye because it arrived shortly after the profitable TP, followed almost immediately by another entry and another stop. That may be a re-entry filter problem, a ribbon-state problem, or just a bad patch of GBPCAD movement. The MT5 report cannot settle it.The MAribbon logs should make it possible to check whether the two losing entries shared the same chart context. I would look first at long-term ribbon direction, distance to resistance, whether the move was still an impulse or already a correction, and why the second long was allowed only about ninety seconds after the previous stop.SummaryThe portfolio’s realized result was positive, but the most useful output from the day is not the ¥624. It is the contrast between systems whose exits were explicit and systems whose exits depended on changing model judgment.The next improvement may not be a new prompt or another indicator. A shared trade ID connecting every LLM response, chart snapshot, position action, and MT5 execution would make the losses far more valuable. Right now the numbers are clear, while the decisions that created them are still partly hidden. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
Winning 57% Wasn’t Enough: GateGrid’s Exit Math Sank the Five-Bot Day
3w ago00:01:36Tap to summarizeThe conclusionJuly 24 was not mainly an entry problem. It was an exit problem.The five-bot portfolio ended the day at -¥461 in realized P/L. GateGrid AI won four of its seven closed trades, giving it a 57.1% win rate, but the payoff ratio was only 0.28. Its winners averaged ¥53, while its losers averaged about ¥189. The final -¥296 loss made me stop for a moment; several small wins had done almost nothing to prepare the account for that exit.LLMBridgeTrader also finished negative, but its loss structure looked different. It lost two of three closed trades, yet its payoff ratio was 0.96 and the final loss was cut at just -¥11. That does not make the day good, but it suggests that the position-management layer was at least willing to abandon a weak idea.BoundSniper Bot and ML_ScoreAnalyst recorded no closed trades. MAribbonTrader opened one GBPCAD position, which remained open with an unrealized loss of ¥17 at the report cutoff.Bot-by-bot results■ GateGrid AI -356 yenRecord: 4W / 3LWin rate: 57.1%Gross profit: +212 yenGross loss: -568 yenPayoff ratio: 0.28Max loss: -296 yen■ LLMBridgeTrader -105 yenRecord: 1W / 2LWin rate: 33.3%Gross profit: +97 yenGross loss: -202 yenPayoff ratio: 0.96Max loss: -191 yenSwap included: +6 yen■ BoundSniper Bot 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ ML_ScoreAnalyst 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ MAribbonTrader 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax realized loss: 0 yenOpen positions: 1Unrealized P/L: -17 yen■ Total -461 yenRecord: 5W / 5LWin rate: 50.0%Gross profit: +309 yenGross loss: -770 yenPayoff ratio: 0.40Max loss: -296 yenUnrealized P/L excluded: -17 yenToday’s theme: the model can choose an entry, but the exit decides the damageThese five bots do not make decisions in the same way.BoundSniper Bot does not predict the market at all. It receives TradingView signals through a webhook and delivers them to MT5. ML_ScoreAnalyst uses a CatBoost score to filter GBPJPY breakout candidates. GateGrid AI is designed as a multi-stage system, using a quantitative gate before asking a local LLM to evaluate volatility, trend, session conditions and grid settings.LLMBridgeTrader gives the AI more freedom. It can propose BUY, SELL or NONE, but it can also choose OPEN, HOLD, CLOSE or REVERSE. It produces confidence, setup type, stop distance, profit target and reasons for entering or exiting. MAribbonTrader goes further into discretionary territory by asking Qwen to read a chart image containing moving-average ribbons, higher-timeframe context, support and resistance, range boxes and channel information.That makes the exit question especially important. An LLM can produce a convincing reason to remain in a position. It can also produce a convincing reason to close it. Only the realized trade tells us whether that flexibility protected the account or merely delayed the loss.The broker statement gives us the actions and outcomes, but not the bots’ internal decision logs. We can see when a position was opened and closed, yet we cannot verify the confidence score, setup classification or written exit reason that led to each action. That missing link matters. The next review should compare the model’s stated reason with the eventual P/L, rather than judging the model only from the broker report.GateGrid AI: the win rate hid an expensive loss structureGateGrid AI closed seven trades on EURUSD during the day. The design memo describes the bot as a GBPUSD system, so either the live configuration has changed or the running instance differs from the documented setup. It is worth recording that configuration change because symbol selection can alter volatility, spread and grid behavior.The first closed position lost ¥67. Two later long positions produced gains of ¥102 and ¥7. Another pair of short positions returned ¥98 and ¥5. At that stage, the sequence probably felt under control.The final two shorts changed the entire result. They were closed together for losses of ¥205 and ¥296.This is the weak point in the day’s result. Four winning trades produced only ¥212 in total, while three losing trades removed ¥568. The bot did not need a higher win rate. It needed either smaller losing exits or more room for the profitable layers to run.GateGrid uses filters before entry, including CatBoost probabilities, session thresholds, ATR conditions and a local Ollama judgment. Those filters may have done their job by selecting several trades that moved in the expected direction. The account still lost because the exit distribution was asymmetric in the wrong direction.The most useful log review is not simply “Why did the bot sell?” It is “Why were the last two positions still being held when their combined loss passed the total value of all four winners?” The answer is probably in the grid-closing or continuation logic, though the broker statement alone cannot prove it.LLMBridgeTrader: a losing day, but a more balanced exit profileLLMBridgeTrader closed three positions for a net realized result of -¥105.The first was a carried position that closed for -¥197 in trading P/L, partly offset by +¥6 in swap. The net loss was therefore ¥191. A new short was then opened at 10:30 and closed eight minutes later for a ¥97 gain. In the afternoon, a long position was opened and abandoned about fourteen minutes later for an ¥11 loss.That last exit is small, but it matters. I saw the -¥11 and thought this is at least the kind of failed idea the account can absorb.The bot’s win rate was only 33.3%, yet its payoff ratio reached 0.96. Average profit and average loss were nearly balanced, unlike GateGrid’s 0.28 ratio. The larger carried loss still dominated the day, but the newer intraday decisions did not show the same pattern of taking tiny gains while tolerating oversized losses.Because LLMBridgeTrader can return HOLD, CLOSE or REVERSE, its quality cannot be measured only at entry. The model must recognize when the original premise has weakened and switch from explanation mode to exit mode. The quick closure of the final long suggests that this transition happened, although the internal reason log is needed before calling it a repeatable improvement.The question for this bot is not whether the AI can describe a good setup. It is whether its confidence falls quickly enough when reality stops matching that description.BoundSniper Bot: no result to judgeBoundSniper Bot recorded no closed trades in the supplied report.That is not automatically a weakness. This bot is an execution bridge rather than a market forecaster. Its performance depends on whether TradingView produced a signal and whether the webhook, tunnel and MT5 execution chain delivered it correctly.With no trades, there is no payoff ratio or exit behavior to evaluate. The useful checks are operational: whether alerts were generated, whether webhook events arrived, whether any orders were rejected and whether the absence of trades was intentional.ML_ScoreAnalyst: the filter stayed inactiveML_ScoreAnalyst also recorded no trades.The system uses CatBoost to score GBPJPY breakout candidates and enters only when the score exceeds its threshold. A no-trade day may mean that no valid candidate appeared, or that candidates remained below the entry threshold.The broker statement cannot distinguish between those possibilities. The score log should show whether the bot spent the day returning NONE or actively rejecting low-scoring setups. Both lead to zero trades, but they say different things about the model.MAribbonTrader: the exit test is still openMAribbonTrader opened one 0.01-lot GBPCAD buy at 1.87744. At the report cutoff, the market price was 1.87729 and the position showed an unrealized loss of ¥17.The trade had a stop at 1.87433 and a target at 1.88175. It had not reached either level, so there is no closed result to score. Its realized P/L remains zero.This is the bot where the exit question may be most revealing. Qwen is being asked to interpret moving-average ribbons, higher-timeframe context, support and resistance, range conditions and channel structure. A chart-reading model can decide that a setup remains visually valid even while the position drifts against it.The next log should show whether the model continues to return HOLD, switches to EXIT before the stop, or lets the original risk plan play out. None of those choices is automatically correct. The value lies in whether the decision is consistent with the reason given at entry.Closing thoughtsA 50% portfolio win rate sounds neutral. A 0.40 payoff ratio is not neutral.July 24 showed how easily a few modest winners can create the feeling that a system is working while one exit sequence does most of the financial damage. GateGrid’s filters may have selected acceptable entries, and LLMBridge may have produced sensible short-term reactions, but the account was still governed by the size of the losing exits.The next improvement should not be another entry filter added on top of the existing ones. I would first connect every CLOSE, HOLD and forced stop to the model’s recorded reason. A bot that can explain why it entered is interesting. A bot that notices when its own explanation has expired is useful. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
Stops That Paid: Two AI Bots Banked ¥599 and Carried the Five-Bot Run
4w ago00:01:42Tap to summarizeConclusionJuly 23 ended with a realized profit of ¥574 across the five-bot lineup. Only three bots had closed trades in the supplied account statements, but two of them did enough: LLMBridgeTrader earned ¥398 and MAribbonTrader added ¥201, while GateGrid AI finished slightly negative at ¥25.What caught my attention was not just the total. Several exits marked as stop-loss orders still closed in profit. That suggests the protective exit layer was doing more than limiting damage; it was also preserving gains after the market had already moved in the bot’s favor.LLMBridgeTrader still held one EURUSD- short position at the end of the report with an unrealized loss of ¥38. That floating result is not included in the ¥574 realized total.Bot Performance■ LLMBridgeTrader +398 yenRecord: 4W / 1LWin rate: 80.0%Gross profit: +644 yenGross loss: -246 yenPayoff ratio: 0.65Max loss: -246 yen■ MAribbonTrader +201 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +201 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ GateGrid AI -25 yenRecord: 8W / 3LWin rate: 72.7%Gross profit: +358 yenGross loss: -383 yenPayoff ratio: 0.35Max loss: -197 yen■ BoundSniper Bot ±0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/A■ ML_ScoreAnalyst ±0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/A■ Total +574 yenRecord: 14W / 4LWin rate: 77.8%Gross profit: +1,203 yenGross loss: -629 yenPayoff ratio: 0.55Max loss: -246 yenToday’s Theme: A Stop Is Not Always a Losing ExitThe account statement contains a useful detail. Four profitable LLMBridgeTrader exits were recorded with stop-related comments, and MAribbonTrader also closed its second trade through a stop-tagged order while still banking ¥41.That ¥41 exit looked modest, but I liked it. A stop that closes above the original entry is no longer just an emergency brake. It becomes a mechanism for turning open profit into realized profit before the market has time to take it back.The exact model reasoning is not included in the broker statement, so I cannot tell whether each stop adjustment came directly from the LLM, a trailing rule, or another risk-management layer. The execution result is clear, though: the profitable bots were able to leave the market with money still on the table.LLMBridgeTrader: Four Winning Exits Absorbed One Full LossLLMBridgeTrader produced five completed EURUSD- trades: +¥261, +¥88, +¥131, -¥246, and +¥164. Seeing +¥398 from only five closed positions was the first number that made me pause.The bot’s design gives the AI a wide decision space. It can propose BUY, SELL, or NONE, select OPEN, HOLD, CLOSE, or REVERSE, and return confidence, setup type, stop distance, target distance, and reasons for entry or exit. Risk checks then decide whether that plan is acceptable.The day was not flawless. Its single ¥246 loss was also the largest loss across all five bots, and the payoff ratio was only 0.65. The average winning trade was smaller than the losing trade, so the result depended on maintaining a high hit rate.Still, the sequence recovered well. Three early winners built ¥480, the loss removed ¥246, and the following ¥164 winner restored the daily result to ¥398. The exit process did not freeze after taking a hit, which matters for a system allowed to reassess positions through an LLM.MAribbonTrader: Two Shorts, Two Profitable ClosuresMAribbonTrader completed two GBPCAD- short trades and won both. The first reached a take-profit exit for ¥160, while the second closed through a stop-tagged order for another ¥41.This bot gives Qwen a chart image containing the short- and long-term MA ribbons, higher-timeframe context, support and resistance areas, range boxes, crossings, and channel information. The model then returns WAIT, BUY, SELL, or EXIT together with its reasoning.Two trades are far too few to prove an edge, and the payoff ratio cannot be calculated because there were no losing trades. Even so, this is the kind of small sample I would rather see: limited activity, no forced entry, and profit retained on both positions.The second trade is the more interesting one for the experiment. It did not need to reach its original target to contribute. The exit layer found a way to close positively, although the broker report alone does not reveal whether that came from the visual model’s judgment or a mechanical stop update.GateGrid AI: Gross Profit Was There, but the Exit Leakage Was LargerGateGrid AI won eight of eleven closed trades and generated ¥358 in gross profit. On win rate alone, the day looked healthy. The problem was that three losses totaled ¥383, leaving the bot down ¥25.The ¥197 loss was the one that bothered me. With an average win of only ¥44.75 and an average loss of roughly ¥127.67, the payoff ratio fell to 0.35. The bot needed almost three average winners to recover one average loss.Before the last two exits, GateGrid AI was ahead by ¥161. The final two closures lost ¥43 and ¥143, removing ¥186 and turning a profitable session into a small negative one. Its entry filters found enough favorable movement to create real gross profit, but the closing sequence gave slightly more back.GateGrid AI uses CatBoost as a quantitative gate before passing selected situations to Ollama. The local LLM then considers items such as spread, ATR, higher-timeframe trends, session, grid width, and recent performance. The broker statement does not contain the AI_SKIP, OLLAMA_HOLD, or decision-reason logs, so this report can evaluate the trade outcomes but not the exact rationale behind each entry.There is also a logging detail worth checking. The system description identifies GateGrid AI as a GBPUSD strategy, while the supplied account statement shows EURUSD-. For this article, I have followed the live account statement.BoundSniper Bot and ML_ScoreAnalystNo closed trades from BoundSniper Bot or ML_ScoreAnalyst appeared in the supplied statements. I have therefore recorded both as flat for this daily comparison rather than assuming anything about their broader operational status.BoundSniper is primarily an execution bridge. It carries TradingView signals through a webhook and local server into MT5, so its value is measured not only by strategy profit but also by execution accuracy, logging, and the absence of missed or duplicated orders.ML_ScoreAnalyst uses a CatBoost score to filter GBPJPY breakout candidates. Since there were no trades to evaluate, the useful evidence for this day would be its skipped signals and score distribution, but those logs were not included in the account report.SummaryThe profitable side of July 23 came from two different AI designs. LLMBridgeTrader used a broad trade-planning framework and recovered after one large loss, while MAribbonTrader took only two positions and kept both positive.GateGrid AI also found profitable moves, but its gross profit did not survive the full exit sequence. That contrast is useful. Entry quality created the opportunity, but the bots that finished ahead were the ones that converted open movement into closed profit.The next step is to connect each broker-side exit with its model output, confidence, decision reason, and stop update history. I do not just want to know which bot made money. I want to know whether the way it kept that money can be reproduced. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →