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
50episodes
Episodes
Newest firstAll episodes
Winning 57% Wasn’t Enough: GateGrid’s Exit Math Sank the Five-Bot Day
3d 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
4d 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 →
Four Wins, Two Losses, Still Down: The Exit Math Beat the Hit Rate
5d ago00:01:37Tap to summarizeThe five-bot run finished at **-221 yen**, even though the closed trades produced four wins and only two losses. The combined win rate was 66.7%, but the payoff ratio was just 0.27. That gap tells the story better than the hit rate does.GateGrid AI posted the largest loss at -351 yen. MAribbonTrader won two of its three trades, yet one -125 yen stop erased the +101 yen collected from the first two. LLMBridgeTrader showed the opposite pattern: its EURUSD short was closed through a stop mechanism after moving into profit, leaving +130 yen behind. The entries mattered, but the day was decided by how each bot stopped holding.Bot-by-Bot Results■ GateGrid AI -351 yenRecord: 0W / 1LWin rate: 0.0%Gross profit: 0 yenGross loss: -351 yenPayoff ratio: N/AMax loss: -351 yen■ BoundSniper Bot +24 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +24 yenGross loss: 0 yenPayoff ratio: N/AMax loss: 0 yen■ LLMBridgeTrader +130 yenRecord: 1W / 0LWin rate: 100.0%Gross profit: +130 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 yenNote: No daily trade report was supplied.■ MAribbonTrader -24 yenRecord: 2W / 1LWin rate: 66.7%Gross profit: +101 yenGross loss: -125 yenPayoff ratio: 0.40Max loss: -125 yen■ Total -221 yenRecord: 4W / 2LWin rate: 66.7%Gross profit: +255 yenGross loss: -476 yenPayoff ratio: 0.27Max loss: -351 yen## Today’s Theme: The Moment a Bot Stops HoldingA win rate can describe how often a decision worked, but it cannot explain how much damage was done when it failed. July 22 made that distinction hard to ignore. Four winning trades averaged 63.75 yen, while the two losses averaged 238 yen.For the LLM-driven bots, the interesting question is not only whether the model selected the correct direction. It is whether the bot knew when the original idea had weakened enough to close, trail, or reverse. An entry model can be slightly wrong and survive. An exit process that stays passive for too long can turn one mistake into the entire day’s result.GateGrid AIGateGrid AI opened an EURUSD short at 1.13997 and closed it at 1.14212 roughly twelve hours later. The result was -351 yen, the largest single loss of the day. I paused at that number because it outweighed every profitable trade from the other bots combined.The design notes describe GateGrid AI as a multi-stage system using CatBoost, local LLM judgment, volatility checks, time filters, and trailing management. The daily broker report alone does not reveal which gate approved this entry or why the position remained open. It also shows EURUSD, while the intended configuration describes GBPUSD, so the live symbol setting deserves a separate check.The immediate issue is the exit path. A filtered entry is useful only if the system can recognize when the approved setup is no longer valid. The next review should match the broker timestamps against the CatBoost score, Ollama response, ATR state, trailing-stop updates, and any hold decision recorded during the position.BoundSniper BotBoundSniper entered a USDJPY long at 163.067 and closed it one minute later at 163.091 for +24 yen. It was a small trade, but the execution chain appears clean: the TradingView instruction reached MT5, the position opened, and the exit followed without a visible operational error.This bot does not predict the market itself, so its result should not be judged like an LLM strategy. Its job is faithful delivery. The useful questions are whether the correct signal was received, whether latency or spread altered the intended price, and whether the exit command was executed once without duplication.There is no meaningful payoff ratio from one winning trade and no losing sample. Still, the trade did what an execution bridge is supposed to do, which matters more than trying to turn +24 yen into a larger claim.LLMBridgeTraderLLMBridgeTrader sold EURUSD at 1.14172 and closed at 1.14092 for +130 yen. The closing comment indicates a stop-based exit, suggesting that the protection level had moved into profitable territory or was otherwise used to lock in the favorable move.This was the most convincing exit of the day. The bot did not need to catch the entire decline. It converted an open gain into a realized result and avoided letting the trade drift back through the entry.The report does not include the model’s confidence, setup label, original SL/TP proposal, or decision text, so it cannot prove whether the LLM itself initiated the final exit. Those logs matter. Still, the live outcome shows a useful separation between AI planning and mechanical protection: the model can propose the trade, while the system makes sure a favorable position does not remain unprotected.ML_ScoreAnalystNo July 22 trade report was included for ML_ScoreAnalyst. I have recorded it as zero closed trades rather than assuming that the bot was inactive.That distinction matters. A score-based bot may correctly skip an entire day because no candidate cleared its threshold, or it may simply have a missing report. The signal log is needed to tell whether the day consisted of valid SKIP decisions, no breakout candidates, a stopped process, or a reporting gap.For this bot, no-trade days are part of the experiment. They become informative only when the candidate score and rejection reason are retained.MAribbonTraderMAribbonTrader completed three GBPCAD shorts. The first two earned +38 yen and +63 yen. The third lost -125 yen, leaving the bot at -24 yen despite winning two of three trades.That loss felt familiar: two correct reads, then one trade large enough to take them both back. The payoff ratio was 0.40 because the average winner was 50.5 yen and the average loser was 125 yen. A 66.7% win rate looks comfortable until that ratio is placed beside it.The final trade was stopped about nine minutes after entry, so this was not a case of holding for hours without protection. The harder question is whether the initial risk was too large relative to the profit the bot usually accepts. If winners are routinely closed around 38 to 63 yen, a 125 yen loss requires an unusually high hit rate just to stay level.Because MAribbonTrader delegates chart interpretation and exit reasoning to AI, its SQLite logs should be used to compare the three trades. The review needs the ribbon state, H4 context, support and resistance, channel room, entry explanation, and exit explanation. The cause may be the stop width, or it may be that the third setup should have been rejected before entry. The broker statement cannot settle that yet.SummaryThe day did not expose a shortage of winning signals. It exposed an imbalance between what the bots were willing to take as profit and what they were willing to surrender when wrong.LLMBridgeTrader left the cleanest clue by protecting a profitable short. MAribbonTrader showed why a respectable hit rate can still leak money, while GateGrid AI showed how one unresolved position can dominate a multi-bot portfolio. The next improvement may not be another entry filter. It may be teaching each bot to notice sooner when staying in the trade has become the risk. 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 →
If You Keep Fixing the Strategy, You May Lose the Ability to Understand It
5d ago00:01:43Tap to summarizeThe day after a loss, every strategy appears easy to improve.The stop was too wide.The entry was too early.The session was wrong.The filter was too weak.There is always something that could have prevented the latest losing trade.So we change it.The next trade loses too.We change something else.Eventually, the strategy has been modified so many times that we can no longer explain what improved or what failed.We wanted a better system.We removed the evidence needed to understand the original one.Change feels like progressDoing nothing during a drawdown feels irresponsible.The account is declining.The same rules are still running.The trader feels expected to act.So the stop is tightened.Another indicator is added.The trading window is reduced.A new market-regime filter is introduced.Editing the code provides immediate relief.The system looks more protected.At least something has been done.But emotional relief and strategy improvement are not the same thing.A change designed to reduce discomfort may not improve long-term performance.Losses do not arrive on scheduleStrategy losses may be distributed over hundreds of trades in a test.Live trading does not deliver them evenly.Several losing trades may arrive together.Different bots may fail during the same market transition.What was expected to occur across several months can appear inside one week.Leverage makes this concentration feel even more significant.At small size, the week may look like ordinary variance.At larger size, it feels like structural failure.The market behavior is identical.The financial pain changes the diagnosis.A trader may believe the strategy is being evaluated objectively while actually reacting to the size of the drawdown.One adjustment creates anotherSuppose a losing streak leads to a tighter stop.The new stop is reached by ordinary price movement.Loss frequency increases.The trader responds by adding stricter entry filters.Trade frequency falls too far.The session is expanded to create more opportunities.The expanded session introduces different spreads and price behavior.Another filter becomes necessary.The first adjustment was small.Its consequences created a chain of additional adjustments.Later, performance improves.Was it the tighter stop?The entry filter?The wider session?Or did the market simply return to a more favorable regime?Nobody knows.The strategy was improved in several places and made impossible to evaluate in any one place.Preserve the baselineTesting requires a comparison.Before and after.The same market.The same costs.The same sizing.The same time horizon.When several variables change together, the comparison disappears.A useful process preserves the original version.Keep one bot on the old configuration.Store the previous parameters.Write one sentence explaining why each change was made.Define the number of trades or amount of time required before judging it.Record what the new rule removes, including the winning trades it may also remove.Improvement is not only the act of adding a better rule.It is also the discipline of protecting the evidence needed to verify that the rule is better.I feel the same urge with trading botsI run several MT5 bots built around different approaches.Some are rule based.Some receive TradingView alerts.Some use machine-learning scores.Some include language-model judgment.After a losing day, the code looks full of obvious improvements.A condition could have avoided this trade.An earlier exit could have protected that profit.A different filter could have rejected the setup.Looking backward makes the answer appear clear.But a rule designed to avoid one historical loss may remove profitable trades in another market.Avoiding a particular loss is not the same as improving the full distribution of outcomes.Without that distinction, a bot gradually becomes optimized for the chart that already happened.Diagnose before changingA negative P&L does not identify the broken component.The problem may be the entry.The direction was wrong, price was chased, or the setup did not fit the regime.It may be the exit.The stop was unsuitable, the strategy gave back profit, or it failed to respond to reversal evidence.It may be the size.The position was too large or several systems carried the same hidden exposure.It may be execution.Spread widened, orders were delayed, or retry logic behaved incorrectly.It may be the market environment.The strategy was designed for movement that was no longer present.The same financial result can come from different operational causes.Changing the full strategy before separating those causes often modifies the parts that were working.Reduce size before rewriting logicMaintaining the same rules during a losing period can still feel dangerous.A practical first response is to reduce size.This is not avoidance.It protects the ability to observe.At full exposure, each result carries more emotional force.Normal variance feels unacceptable.The need to recover becomes stronger.Parameter changes become more urgent.Smaller size reduces the financial pressure without immediately changing the system being evaluated.The strategy can continue producing evidence.Losses have less impact on the account.A favorable regime can return without the original logic having been removed.During a drawdown, the first goal is not always to find the answer immediately.It may be to preserve enough capital and mental space to recognize the answer later.Doing nothing still requires a plan“Do nothing” can become a dangerous excuse.A genuinely broken strategy can be allowed to continue under the label of patience.Observation needs boundaries.For example:Keep the logic unchanged for the next twenty trades.Run at half size.Record entry, exit, spread, session, and execution quality.Separate rule-following losses from operational failures.Stop if the drawdown exceeds a predefined limit.After the observation window, select only one modification to test.This is not passive neglect.It is a controlled period in which changes are delayed so that evidence can remain comparable.Useful improvements are often boringStrategy improvement is often associated with major additions.A new AI model.A new indicator.A new entry engine.A new market.In production, the most valuable changes may be less dramatic.Rejecting trades during excessive spread.Improving retry logic.Preventing duplicate exposure.Writing better logs.Defining restart conditions.Correcting position-size calculations.Each change is small.None creates a completely new strategy.Together, they remove repeated operational mistakes.A modest improvement that remains active for years may contribute more than a sophisticated idea that is replaced after the next drawdown.Activity is not evidence of improvementA large amount of work can be completed without making the strategy better.More code.More backtests.More parameters.More filters.The useful questions remain:What improved relative to the original?Did it improve in unseen periods?Does the result survive transaction costs?Which profitable trades were removed?Can the change be explained and repeated?Changing a strategy is easy.Keeping it unchanged long enough to learn from it is harder.That waiting period is not wasted time.It is what makes the next adjustment interpretable.The same pattern appears outside tradingA newsletter fails to grow, so the topic changes.A product receives little attention, so new features are added.A study method feels slow, so another course is purchased.Changing the method produces a sense of movement.But when the method changes before results have enough time to appear, no learning accumulates.Improvement requires adjustment.It also requires periods of stability.Without stable periods, the effect of each adjustment remains invisible.Preserve before you repairThere is no perfect trading strategy.Losses cannot be removed completely.Unexpected clusters will occur.Rebuilding the system after each one prevents the strategy from developing a reliable history.The answer is not to ignore poor results.It is to slow the rate of change when poor results create the strongest urge to act.Reduce size.Separate the causes.Keep the logs.Preserve the baseline.Change one variable.Wait long enough to observe the result.Before repairing the strategy, protect the process that allows you to learn what needs repair.Is the next adjustment truly designed to improve the system?Or is it mainly designed to make the latest loss feel easier to live with? This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit <a href="https://fxaibotlab.substack.com/subscribe?utm_medium=podcast&#...
Transcribe →
It Wasn’t the Entry or the Exit: Why I Moved GateGrid AI From GBPUSD to EURUSD
6d ago00:01:36Tap to summarizeMy five MT5 trading bots finished July 20 with a combined realized loss of ¥542.The closed trades produced three wins and five losses. The average winning trade made ¥32.7, while the average losing trade lost ¥128. That gives an average payoff ratio of only 0.26.BoundSniper Bot was the only system to finish positive, earning ¥16.GateGrid AI lost ¥151, LLMBridgeTrader lost ¥167, and ML_ScoreAnalyst lost ¥240. I did not receive a confirmed report for MAribbonTrader, so I recorded it as an unverified ¥0 rather than assuming that it made no trades.When I first reviewed the day, I thought the main issue was the exit logic.Several different bots were producing the same pattern: small profits were closed quickly, while larger losses were allowed to remain.That interpretation was not completely wrong.However, after a deeper investigation into GateGrid AI, I reached a different conclusion.The exits were weak, but improving them was not enough. Better entry selection was not enough either.The GBPUSD version of the strategy could not produce a positive expected value under realistic trading costs.The real issue was not simply how intelligent the bot was.It was the relationship between the strategy, the currency pair, and the cost paid on every trade.The July 20 loss became the final reason to reconsider whether GateGrid AI should continue trading GBPUSD at all.Results by BotGateGrid AI: -¥151GateGrid AI traded GBPUSD and finished with zero wins and two losses.A buy stop was triggered first. The sell-side order was then triggered as well, and both positions were closed roughly one second later.The two results were -¥135 and -¥16.Looking only at this sequence, the problem appeared to be the position-management process after the opposite side was filled.Should the system keep both positions as a hedge?Should it treat the second fill as a reversal and close the first position?Should it classify the situation as abnormal and close everything?The trade report did not show which rule caused the exit.In the past, I would have responded by adding more detailed exit logs and adjusting the position-management logic.In fact, I had already made many such adjustments.The long-term performance still failed to improve.BoundSniper Bot: +¥16BoundSniper Bot traded USDJPY.It bought at 162.348 and closed approximately four minutes later at 162.364, producing a ¥16 profit.One trade is not enough to evaluate the quality of the underlying signal.However, the execution path worked correctly. The bot received the TradingView webhook, placed the MT5 order, closed the position, and left nothing open.BoundSniper Bot does not predict the market by itself. Its job is to carry an external TradingView signal into MT5.For that reason, the important risks are different: communication latency, duplicate orders, symbol conversion failures, rejected orders, and missed exits.The profit was small, but the execution process was clean.LLMBridgeTrader: -¥167LLMBridgeTrader traded EURUSD.Its three results were -¥141, +¥73, and -¥99.That produced one win and two losses. The average win was ¥73, while the average loss was ¥120, giving an average payoff ratio of 0.61.All three positions were closed at market before reaching their original stop-loss or take-profit levels.This suggests that the LLM-based OPEN, HOLD, CLOSE, and REVERSE decision process was active.But an active decision process is not necessarily a profitable one.Did the model close profitable trades too early?Did it correctly detect a reversal?Did it wait longer when a position was losing than when it was winning?The trade history alone cannot answer those questions.The system needs to record the model name, prompt version, market inputs, confidence score, proposed action, final action, and exact exit reason for every decision.ML_ScoreAnalyst: -¥240ML_ScoreAnalyst traded GBPJPY.It produced one ¥9 profit and one ¥249 loss.Its average payoff ratio was only 0.04.It would take nearly 28 wins of ¥9 to recover a single ¥249 loss.This bot uses a CatBoost score to select entries. However, a high entry score is not enough when the expected price movement is much smaller than the stop-loss distance.Raising the score threshold alone will not solve the problem.The score threshold, trading session, ATR, entry volatility, stop distance, and target distance need to be tested as one combined policy.The bot also carried an unrealized loss of ¥97 into the next day.That unrealized amount was not included in the realized loss of ¥542. Including it would bring the total daily mark-to-market result to -¥639.MAribbonTrader: Unverified ¥0I did not receive a July 20 trade report for MAribbonTrader.I therefore recorded it as an unverified ¥0 rather than declaring that it made no trades.For an LLM bot that reads chart images, BUY and SELL are not the only meaningful outputs.WAIT and EXIT are also decisions.The input image, higher-timeframe context, support and resistance levels, model response, and reason for waiting should all be recorded.A day with no trades can still contain valuable information, but only if the system distinguishes between deliberately waiting and failing to run.GateGrid AI Was Winning Most Trades and Still Losing MoneyI did not judge GateGrid AI from the two losses on July 20 alone.Across its live trading history, the bot won approximately 62–68% of its trades.At first glance, that appears acceptable.Despite that win rate, its live profit factor was only 0.62, and its lifetime loss was approximately ¥19,000.The problem was not just an occasional large loss.The system was losing small amounts on an almost daily basis.Converted into pips, the average winning trade made only 4.3 pips, while the average losing trade lost 15.3 pips.The average loss was roughly 3.5 times larger than the average win.With that payoff structure, the break-even win rate is approximately 78%.The actual win rate of 62–68% was not close enough.A minor improvement in entry accuracy could not bridge the gap.This asymmetry was not simply a programming bug.GateGrid AI closes profitable positions relatively quickly and adds exposure when the market moves against the grid.Small gains are collected frequently, but losing baskets become much heavier.The negative skew was embedded in the strategy itself.GBPUSD Trading Costs Were Too Large Relative to the Average WinSpread was another factor quietly damaging the system.In live observations, GBPUSD spread sometimes reached roughly 1.2 pips.For a strategy whose average winning trade was only 4.3 pips, that cost was substantial.A 1.2-pip spread consumes about 28% of the gross winning distance.In my cross-pair simulations, I used a 0.7-pip spread for GBPUSD. Even under that more favorable assumption, it remained expensive compared with the roughly 0.3-pip conditions available on EURUSD and USDJPY.For a strategy targeting large moves, a difference of 0.4 pips may be relatively minor.For a system repeatedly collecting around four pips, that difference sits near the center of the expected value calculation.Reducing the spread paid on every trade can matter more than improving entry accuracy by a few percentage points.I Had Already Made Extensive Exit AdjustmentsGateGrid AI’s exits had not been ignored.I increased the trailing ratchet from 0.7 to 0.9.I added a time-decay mechanism that gradually reduced the global stop-loss distance to 15 pips after 180 minutes.I introduced an ¥800 basket loss limit.I blocked new entries on Mondays and before the trading curfew.These changes reduced the size of the tail losses.However, they did not close the gap between the required 78% win rate and the actual win rate of roughly 68%.Exit adjustments could reduce the severity of the losses, but they could not reverse the expected value of the strategy.That left one remaining possibility: improve the entries.Six Attempts to Improve Entry Quality FailedI used one rule for every experiment.A change would only be accepted if it improved performance consistently across multiple periods.A policy that worked in only one selected period would not be considered valid.Regime SwitchingI tested a model designed to classify whether the market was ranging or breaking out and then change the grid behavior accordingly.The holdout AUC was 0.57, and the resulting trading policy showed no improvement.The model could describe something resembling market conditions, but it could not separate profitable conditions from unprofitable ones.Gate Model Version 2I used 16,715 previously unused market snapshots and generated counterfactual labels to rebuild the entry gate.The real holdout AUC reached 0.61.Despite the higher classification score, the trading policy became worse by ¥46 per trade.A model can improve its statistical metric while reducing actual trading performance.This experiment also revealed that the existing combined policy of threshold filtering, Ollama judgment, and the clean gate was better than simply sorting trades by the model score.Replacing the LLMI attempted a shadow test using gpt-oss:20b in place of the current Ollama decision model.Under the current configuration, however, the model returned empty responses.It appeared faster...
Transcribe →
The Day Was Lost at the Exit, Not the EntryJuly 17
1w ago00:01:47Tap to summarizeConclusionThe five-bot portfolio finished July 17 at -1,362 yen realized, with another -175 yen unrealized on an open ML_ScoreAnalyst position. The combined mark-to-market result was therefore -1,537 yen.The loss itself is not the most useful part of the record. Exit structure separated the bots far more clearly than entry style did. MAribbonTrader won only one of two trades, yet ended positive because its average winner was 1.74 times its average loser. GateGrid AI, LLMBridgeTrader, and ML_ScoreAnalyst produced seven losing closes between them without a single winner to absorb the damage.The -602 yen stop on ML_ScoreAnalyst made me pause. It was not an unusual malfunction; it appears to be the intended fixed-stop design doing exactly what it was told to do. That may be more uncomfortable than a software error, because it points back to the payoff geometry itself.Bot-by-Bot Results■ GateGrid AI -393 yenRecord: 0W / 3L (Win rate 0.0%)Gross profit: 0 yenGross loss: -393 yenPayoff ratio: Not availableMax loss: -252 yen■ BoundSniper Bot +10 yenRecord: 1W / 0L (Win rate 100.0%)Gross profit: +10 yenGross loss: 0 yenPayoff ratio: Not availableMax loss: 0 yen■ LLMBridgeTrader -479 yenRecord: 0W / 2L (Win rate 0.0%)Gross profit: 0 yenGross loss: -485 yenSwap: +6 yenPayoff ratio: Not availableMax loss: -290 yen■ ML_ScoreAnalyst -602 yen realizedRecord: 0W / 1L (Win rate 0.0%)Gross profit: 0 yenGross loss: -602 yenPayoff ratio: Not availableMax loss: -602 yenOpen P/L: -175 yen■ MAribbonTrader +102 yenRecord: 1W / 1L (Win rate 50.0%)Gross profit: +240 yenGross loss: -138 yenPayoff ratio: 1.74Max loss: -138 yen■ Total -1,362 yen realizedRecord: 2W / 7L (Win rate 22.2%)Gross profit: +250 yenGross loss: -1,618 yenSwap: +6 yenPayoff ratio: 0.54Max loss: -602 yenOpen P/L: -175 yenResult including open P/L: -1,537 yenToday’s Theme: An Entry Filter Cannot Rescue a Weak ExitThese five bots do not make decisions in the same way. BoundSniper relays TradingView instructions. ML_ScoreAnalyst scores a setup with CatBoost. GateGrid AI adds several entry gates before allowing a trade. LLMBridgeTrader lets an LLM choose OPEN, HOLD, CLOSE, or REVERSE. MAribbonTrader asks a local model to read chart structure and then trades around that interpretation.Despite those differences, the day converged on one issue: what happened after entry.A bot can reject mediocre setups, score a breakout correctly, or produce a persuasive market explanation. None of that guarantees a durable result if the position is held until a distant fixed stop, if reversal handling creates overlapping exposure, or if the model does not abandon its original thesis soon enough.The useful experiment is no longer just “Did the model pick the right direction?” It is “What information was available when the trade should have been closed, and what did the bot decide to do with it?”GateGrid AI: Multiple Gates, but the Exit Sequence Still HurtGateGrid AI closed three losing GBPUSD trades for -393 yen. The first short was opened at 1.34598 and covered at 1.34753 for -252 yen. That was the largest loss inside this bot.The later sequence deserves more attention. A buy was filled at 1.34762, then a sell was filled at 1.34681. Both sides were closed at 10:17, producing losses of -130 yen and -11 yen. The record shows simultaneous opposing exposure and an immediate flattening sequence. That looks less like a simple bad directional call and more like a coordination problem around reversal, hedging, or grid shutdown.GateGrid’s CatBoost and Ollama layers are designed to be selective before entry. On this day, the missing evidence is what happened after those gates opened. The next log review should align the model score, Ollama response, active grid state, close trigger, and any reversal flag on the same timeline. Without that, tuning the entry threshold would be guesswork.BoundSniper Bot: The Bridge Worked, but One Tiny Win Proves LittleBoundSniper opened a USDJPY short at 162.255 and closed it 45 seconds later at 162.245 for +10 yen. The trade was clean, fast, and profitable.That is encouraging from an execution perspective. The TradingView instruction reached MT5, the position was opened, and the exit was transmitted without a visible operational failure. Since BoundSniper does not create the market thesis itself, this is exactly the part of the system it needs to perform well.Still, a 100% win rate from one trade is mostly decoration. There was no losing trade, so the payoff ratio cannot be calculated. The result says the bridge functioned; it does not yet say the upstream TradingView strategy has an edge.LLMBridgeTrader: The LLM Had Control of the Exit, but the Hard Stop Did the WorkLLMBridgeTrader finished at -479 yen after swap. One position closed for -290 yen, while a later EURUSD short lost -195 yen.The second trade is the cleaner test because both entry and exit appear in the day’s report. The bot sold at 1.14275 at 14:00 and exited at 1.14395 at 17:17. The position remained open for more than three hours and eventually closed at the stop level.This bot is allowed to return HOLD, CLOSE, or REVERSE. That makes the exit path the central part of the experiment. Yet the live result looks no more adaptive than a trade held until a mechanical stop. I cannot say the LLM ignored an obvious exit without seeing its decision logs, but the record gives no sign that its broader authority improved the outcome.For the next review, every HOLD decision should be stored with current unrealized P/L, recent price structure, confidence, and the reason the model rejected CLOSE. The most valuable training examples may be the moments when the model kept defending a position that later stopped out.ML_ScoreAnalyst: The Model Score Is Only Half the BetML_ScoreAnalyst bought GBPJPY at 218.605 and was stopped at 218.003 for -602 yen. It then opened a new short that remained active at the end of the report with -175 yen unrealized.The closed loss is consistent with the bot’s roughly 60-pip stop setting. The profit target is around 25 pips. That structure needs a win rate of about 70.6% before trading costs just to break even. A scoring model can be directionally useful and still struggle under that burden.This is why the -602 yen loss matters beyond one bad trade. It is the natural consequence of a design where one full stop requires more than two normal target wins to repair. Raising the CatBoost threshold may reduce weak entries, but threshold tuning alone will not fix an unfavorable payoff profile.The open short also matters. Realized performance was -602 yen, but actual end-of-day exposure made the bot’s contribution -777 yen on a mark-to-market basis. The next test should compare the existing 60/25 structure with volatility-adjusted exits and a less asymmetric fixed alternative.MAribbonTrader: A 50% Win Rate Was EnoughMAribbonTrader was the most balanced result of the day. Its first GBPCAD short earned +240 yen. Its second short lost -138 yen. The final result was +102 yen with a 50% win rate and a payoff ratio of 1.74.That is the cleanest exit profile in the group. The winner was allowed to reach its target, while the loser remained smaller than the prior gain. The second loss included some slippage around the stop, but it did not erase the first trade.Two trades are not enough to validate chart-reading intelligence. The model may have read the MAribbon context well, or it may simply have landed on a favorable pair of trades. What can be said from the execution record is narrower and more useful: the exit geometry gave the bot room to survive an ordinary loss.For this bot, the next layer of analysis should connect each result to the image prompt, the detected ribbon state, the model’s WAIT or entry rationale, and the reason for exit. The positive result is welcome, but the reusable evidence lives in those logs.SummaryThe portfolio’s 22.2% win rate was weak, but the deeper issue was the total payoff ratio of 0.54. Gross profits reached only +250 yen against -1,618 yen in gross losses. A system cannot filter its way out of that imbalance forever.The next improvement should be built around exit snapshots rather than another round of entry optimization. For every open position, the bots need a record of maximum favorable excursion, maximum adverse excursion, model confidence, exit recommendation, and the reason a close was postponed. That would show whether losses came from poor entries, slow recognition, rigid stops, or confused reversal handling.Bots reveal their real character after they are already in the market. July 17 made that part unusually visible. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
The Illusion of Win Rate and the Challenge of the “Exit”
2w ago00:01:34Tap to summarizeLooking back at the operating logs of the AI trading bots on July 15 and 16, a clear and somewhat painful theme has emerged. It is the reality that “the timing of the exit (closing a position) is far more important than the frequency or accuracy of the entry.”The Illusion of Win Rate and the Payoff Ratio (Lessons from July 15)On July 15, we ran four MT5 bots, ending the day with a total loss of -1,456 JPY.Some bots recorded a 50% win rate that day, yet the account balance still decreased. Overall, the record was 6 wins and 8 losses (a 42.9% win rate), meaning they were not losing excessively. The bots were not wildly misjudging the market direction all day.The problem was that they were “paying too much when they were wrong.” The payoff ratio was only 0.51, meaning the average profit was only half the size of the average loss. Even if small profits are accumulated, a single loss, inflated by a delayed exit, can wipe them all out. Faced with such results, the “win rate” metric feels like mere noise.AI’s Struggle and the Victory of Simplicity (Lessons from July 16)On the following day, July 16, we ran five bots, including the newly added MAribbonTrader. The realized profit and loss was -464 JPY.On this day, the difference in the bots’ “approaches” clearly divided the results. The most outstanding performer was, ironically, the least “conversational” bot, ML_ScoreAnalyst. Without hesitation, this system successfully hit the take-profit on both of its two trades, generating a profit of +502 JPY on its own.In contrast, the bots that relied on LLMs (Large Language Models) or image recognition AI for judgment struggled with “cutting losses,” “switching positions,” and “staying out of the market.” The decision of whether to “HOLD” or “CLOSE” a position after entering proved to be the most costly challenge.Behavior and Challenges of Each BotOver these two days, the different risks associated with each of the five bots became apparent.* GateGrid AIOn the 15th, despite a 50% win rate, delayed exits made the trades too costly, resulting in a loss. On the 16th, it showed inexplicable behavior, closing a trade in the same second it was opened, resulting in a -13 JPY loss. While the entry filter is functioning, a detailed log review of the handoff between execution and closing is necessary.* BoundSniper BotThis is a rule-based bot that executes signals received from TradingView. It had a 50% win rate on the 15th, but on the 16th, it suffered seven consecutive losses after one win, dropping its win rate to 12.5%. The issue is not the execution engine itself; improving the quality of the upstream signals and revising the exit rules during losing streaks is urgently needed.* LLMBridgeTraderOn the 15th, despite a 33.3% win rate, it limited its losses and showed a decent structure with a payoff ratio of 1.23. However, on the 16th, immediately after a loss, it quickly took a position in the opposite direction and held an unrealized loss (-145 JPY). Measures are needed to prevent delayed withdrawals and overreaction (chasing) after a loss.* ML_ScoreAnalyst (formerly MLScore GF-T4)On the 16th, it successfully took profit on two GBPJPY long trades, achieving a commendable result of +502 JPY. However, on the 15th, it had a record of “a winning trade of +300 JPY and a losing trade of -599 JPY,” revealing the issue of its stop-loss being too wide. We must continue to evaluate the “true cost” of this wide stop-loss, rather than just trusting clean wins like those on the 16th.* MAribbonTraderThis bot, which uses image recognition AI to read charts, held a position for over 12 hours on the 16th, resulting in the largest single loss of the day (-447 JPY). The market context must have changed during that long holding period, making it necessary to verify whether the exit mechanism is functioning properly.Next Steps: Towards Exit DisciplineIn live automated trading, what protects the day’s profits is the decision that “I will not hold this position any longer.” The results of these tests teach us that future system improvements should focus on “exit discipline” rather than “entry confidence.”In the next iteration, we will implement the following changes:* Detailed State Logging: Record the position direction, unrealized P/L, model confidence, and the reason for the decision (e.g., HOLD or CLOSE) as a compact log to make the validity of the closing decision verifiable.* Review Maximum Holding Time: Set re-evaluation triggers based on elapsed time to reduce the risks associated with holding positions for a long time.* Introduce Cooldowns: Prevent immediate entries right after a loss is finalized, separating genuine trend reversals from “emotional chasing.”Systems equipped with advanced AI models have, ironically, left us with the most human and difficult question of “when to exit.” However, these clear differences between the systems and the records of their failures are precisely the most valuable data we need to push them to the next level. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
The Win Was Real, But the Open Loss Stole the Room
2w ago00:01:51Tap to summarizeConclusionClosed trades finished at +1,103 yen across the four bots. That sounds clean at first glance, and part of me wanted to leave it there. But BoundSniper carried an open floating loss of -641 yen, which pulled the effective result down to +462 yen. I paused at that number, not because it was disastrous, but because it reminded me how easily a good-looking day can become an exit problem.The entries were not the main story today. GateGrid AI and MLScore GF-T4 GB did their job, LLMBridgeTrader struggled, and BoundSniper did not close at all. The lesson is uncomfortable but useful: when an LLM or an automated system is allowed to decide whether to keep holding, the exit logic deserves as much attention as the entry signal.Bot-by-bot results■ GateGrid AI +852 yenRecord: 11W / 1LWin rate: 91.7%Gross profit: +1,006 yenGross loss: -154 yenPayoff ratio: 0.59Max loss: -154 yenFloating P/L: 0 yen■ BoundSniper 0 yenRecord: 0W / 0LWin rate: N/AGross profit: 0 yenGross loss: 0 yenPayoff ratio: N/AMax closed loss: N/AFloating P/L: -641 yen■ LLMBridgeTrader -266 yenRecord: 2W / 3LWin rate: 40.0%Gross profit: +116 yenGross loss: -382 yenPayoff ratio: 0.46Max loss: -196 yenFloating P/L: 0 yen■ MLScore GF-T4 GB +517 yenRecord: 2W / 0LWin rate: 100.0%Gross profit: +517 yenGross loss: 0 yenPayoff ratio: N/AMax loss: N/AFloating P/L: 0 yen■ Total +1,103 yen realizedRecord: 15W / 4LWin rate: 78.9%Gross profit: +1,639 yenGross loss: -536 yenPayoff ratio: 0.82Max closed loss: -196 yenFloating P/L: -641 yenEffective P/L: +462 yenToday’s themeToday was a reminder that win rate can flatter the system. The total win rate was 78.9%, which looks strong, and GateGrid AI alone printed 11 wins from 12 exits. Still, the combined payoff ratio was only 0.82, so the average win was smaller than the average loss. That is not a fatal structure for a high-win-rate system, but it leaves less room for a single awkward hold.The bigger issue was the open position. BoundSniper had no closed result, so it looked harmless in realized P/L, yet its -641 yen floating loss was larger than every closed loss of the day. That is the part that made me stop and look twice. The damage was not booked, but it was already sitting there.GateGrid AIGateGrid AI was the strongest closed-trade performer today. It ended at +852 yen, with 11 wins and 1 loss, and the largest win was +424 yen. That single +424 yen trade helped cover a lot of smaller exits, and honestly it made the log feel safer than it really was for a moment.The weak point is the payoff ratio. At 0.59, the average win was still smaller than the average loss. GateGrid AI can survive that when the CatBoost gate, Ollama filter, ATR checks, session thresholds, and trailing management keep the win rate high. But if the entry filter loosens or the market starts chopping harder, that ratio can become a quiet problem.As an LLM/ML hybrid, GateGrid’s best behavior today was not just entering. It also exited without letting the one loss grow beyond -154 yen. That matters. For a grid-style bot, the real test is whether the model can stop building exposure when the setup gets stale, and today it mostly did.BoundSniperBoundSniper closed nothing today. On paper, the realized result is 0 yen, but the open EURUSD position was sitting at -641 yen by the report time. This is the number that changed the whole reading of the day. A flat realized result is not neutral when the position is still bleeding.BoundSniper is mainly an execution bridge for TradingView signals rather than a bot that predicts the market itself. That means the quality of the day depends heavily on whether the external signal provides a timely exit, and today the exit had not arrived by the cutoff. Maybe the strategy is built to hold through this kind of drawdown. I do not know that from this report alone, so I do not want to overstate it. Still, for live operation, the open-loss rule needs to be treated as part of the system’s score, not as an afterthought.LLMBridgeTraderLLMBridgeTrader had the most interesting failure pattern. It won twice, then gave back more than it earned through three losses. The final result was -266 yen, and the payoff ratio was 0.46. When I saw the -196 yen stop loss, I had the familiar reaction: this is probably not an entry-only issue.This bot gives the AI more responsibility. It can decide BUY, SELL, NONE, and also OPEN, HOLD, CLOSE, REVERSE, or NONE. That makes the exit decision central. Today, the losing trades suggest the model either held too long, changed its view too late, or accepted setups where the expected reward was too thin. I cannot prove the exact reason without the prompt log, but the shape points toward exit judgment and risk-reward filtering more than raw direction alone.The good side is that the losses were not uncontrolled. The max closed loss was -196 yen, not a runaway event. But the two wins were only +45 yen and +71 yen, so the bot needs either cleaner exit timing or a stricter rule that blocks trades when the likely reward is too small.MLScore GF-T4 GBMLScore GF-T4 GB did exactly what a small automated system needs to do on a quiet report: it took two closed wins and finished at +517 yen, including +13 yen swap. Both exits hit TP-style comments, and there were no open positions left at the cutoff.There is not enough detail in the report to make a deep claim about the model behind MLScore. I will keep this modest. The result was clean, the exits were clean, and unlike BoundSniper, it did not leave a floating problem behind. Some days that is enough.Wrap-upThe day was profitable, but not as comfortable as the closed P/L suggested. GateGrid AI and MLScore carried the board, LLMBridgeTrader exposed the cost of weak payoff structure, and BoundSniper reminded me that unrealized risk is still risk. The next thing I would check is not just which bot entered well, but which bot knew when the trade had stopped being worth holding.② Substack NoteFour MT5 bots finished July 14 with +1,103 yen in closed P/L, but the cleaner headline hides the real lesson.GateGrid AI and MLScore did the lifting. LLMBridgeTrader struggled with payoff. BoundSniper carried a -641 yen open loss, which made the effective result much smaller.Today was less about entry accuracy and more about exits. The trade that is not closed yet can still become the main story. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
Do Not Trade the Warning
2w ago00:01:22Tap to summarizeYou can identify a reversal early and still lose the trade.Price makes a new high.Momentum fails to confirm it.The divergence looks clear.You sell.Price continues higher.You are stopped out.Another divergence appears.You sell again.The market keeps moving in the same direction.Eventually, the reversal may happen.But by then, your capital and patience may already be damaged.The warning was not necessarily wrong.You simply treated it as if the event had already happened.Weakening is not the same as reversingWhen price continues higher while momentum becomes weaker, something has changed inside the move.The trend may be losing energy.But losing energy does not mean the trend has ended.A car can slow down without stopping.It can stop without reversing.Momentum indicators can reveal that the current move is no longer as strong as it was.They cannot guarantee when price will turn.As long as buyers remain in control, price can continue making new highs even while momentum declines.Divergence identifies tension.It does not resolve it.The earlier the entry, the longer the fightCalling a top or bottom early is attractive.The potential reward is larger.The entry looks impressive after the reversal happens.But an early countertrend position must survive the part of the move that has not finished.Selling an active uptrend means holding while buyers are still in control.Buying an active downtrend means standing in front of sellers who have not stopped.Even if the final direction is correct, the trade can fail before the market proves it.Being early is not always different from being wrong from the account’s point of view.Let the warning change what you watchA divergence does not have to trigger an order.It can move the market into a higher-alert state.After bearish divergence in an uptrend, you might wait for:A break below a recent swing low.Failure to make another higher high.A clear break of trend structure.A weak recovery after the first decline.A candle close that confirms selling pressure.The exact trigger depends on the strategy and timeframe.The sequence matters more than the specific tool.Momentum identifies the warning.Price confirms the change.Risk determines whether the trade is worth taking.Confirmation has a costWaiting for confirmation means giving up part of the move.You will not sell the exact top.You will not buy the exact bottom.The entry may offer a smaller reward relative to the stop.That can feel inefficient.But early entry has costs too.Multiple stop-outs.Long periods of holding against the trend.The temptation to increase size because the reversal feels overdue.The mental strain of defending a prediction price has not confirmed.The choice is not between a perfect early entry and a late entry.It is between paying for confirmation with some lost distance, or paying for anticipation through additional uncertainty and failed attempts.Separate alerts from ordersThis distinction becomes especially useful in automated trading.A simple bot often turns every detected condition into an order.RSI reaches a threshold.Moving averages cross.Divergence appears.Buy or sell.The code is clean.The logic may be too compressed.In an MT5 bot, I would treat divergence as an alert layer.Then I would require separate confirmation from price structure.I would also check spread, trading session, and major-event restrictions before allowing an order.This creates more conditions and fewer trades.It also prevents one indicator from carrying responsibility it was never designed to handle.Detection and execution should be separate layers.Give every signal one jobWhen a strategy struggles, traders often add more indicators.RSI.MACD.Moving averages.Volume.Volatility filters.More information does not always create clearer decisions.It helps to assign each input a specific role.One tool identifies the market environment.Another detects weakening momentum.Another confirms entry.Another adjusts position size.Another stops the system.For example:The higher timeframe defines the trend.Divergence creates an alert.A swing break confirms the change.Spread and session rules permit execution.A drawdown limit stops trading.Not every indicator needs to answer buy or sell.Some signals are more useful when they only tell you what to watch next.A warning can still protect an open positionNot trading divergence does not mean ignoring it.A warning can change how you manage existing risk.You may avoid adding a new position.Take partial profit.Reduce size.Tighten operational oversight.Stop giving the trend unlimited benefit of the doubt.Divergence may be unreliable as a standalone entry.It can still be valuable as a reason to become more cautious.Between noticing and actingMarkets reward awareness.Seeing a change before it becomes obvious can be useful.But observation and execution are different skills.Something looks weaker.The move feels different.Momentum no longer supports price.That is the beginning of analysis, not the end.The next question is whether price has confirmed the change.Does your signal tell you that something may happen?Or does it tell you that it already has?Before turning a warning into a position, make sure you know which job the signal is doing. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit fxaibotlab.substack.com/subscribe
Transcribe →
Weekly Report: The One Loss That Mattered More Than All the Wins
2w ago00:01:40Tap to summarizeFrom July 6 to July 10, 2026, I continued running four MT5 automated trading bots in parallel.The four systems were:* GateGrid AI* BoundSniper Bot* LLMBridgeTrader* MLScore GF-T4 GBThe combined realized result for the week was -3,060 yen.On paper, it was simply a losing week.But when I reviewed the logs, the total loss itself was not what stood out most.The bots did not struggle to win trades.In fact, there were several days when the number of winning trades looked fairly strong.And yet, the account still lost money.That gap appeared again and again throughout the week.The real issue was not how often the bots won.It was how much they gave back when they lost.July 6: A difficult start to the weekThe result for July 6 was -1,976 yen.The combined record was 1 win and 10 losses.It was the worst day of the week.LLMBridgeTrader recorded the only winning trade, while GateGrid AI lost 733 yen and MLScore lost 621 yen.The directional calls were not good, but the larger problem was how long some losing positions remained open.Instead of exiting when the trade idea began to fail, the bots often waited until the loss had already grown.The weakness in the exit logic was visible from the very first day.July 7: Thirteen wins, but only 276 yen in profitThe result for July 7 was +276 yen.The combined record was 13 wins and 3 losses.At first glance, that looks like an excellent day.However, the payoff ratio was only 0.31.There were very few losing trades, but each loss was much larger than each win.As a result, 13 winning trades produced only a small net profit.GateGrid AI is the clearest example.It won 8 of its 11 trades.Even so, it finished the day at -230 yen.Eight small wins were erased by three larger losses.Looking only at the win count, I might have concluded that the bot was performing well.In reality, the structure was fragile.As long as the bot kept collecting small gains, the weakness remained hidden.Once a deeper loss appeared, most of the previous profits disappeared.July 8: More wins than losses, but still negativeThe result for July 8 was -620 yen.The combined record was 9 wins and 7 losses.Again, the number of winning trades was higher than the number of losing trades.But the day still ended in the red.The biggest factor was a single -418 yen loss from BoundSniper.Small profits from the other trades could not absorb one large loss.This was another reminder that win count alone says very little about the actual health of a trading system.July 9: One loss erased everythingThe result for July 9 was -481 yen.There were only three trades in total, with 2 wins and 1 loss.It was a quiet day.However, the single losing trade came from GateGrid AI and cost 542 yen.That one loss erased all the small profits produced by the other bots.Two out of three trades were correct.The day still ended negative.This shows why improving directional accuracy alone is not enough.The more important question is how cheaply the system can exit when it is wrong.July 10: MLScore performed well, but the portfolio still fell shortThe result for July 10 was -259 yen.The combined record was 12 wins and 8 losses.MLScore GF-T4 GB closed two short positions at take profit and earned +483 yen.For this bot, it was one of the cleanest results of the week.However, the gains were not enough to cover the losses from the other systems.MLScore performed well on its own, but when four bots are running together, individual results are not the only thing that matters.I also need to watch how losses overlap across the portfolio.GateGrid AI: Winning often, but failing to keep the profitGateGrid AI showed the clearest weakness this week.On July 7, it won 8 of 11 trades.It still lost 230 yen.Then, on July 9, a single trade produced a 542 yen loss.The pattern is familiar.The bot collects many small gains, then gives them back in one deeper loss.The entry filters are not completely broken.In fact, many trades still close in profit.The problem begins after entry.When the market changes and the original setup loses validity, the bot often remains in the position for too long.Instead of making the entry logic even more complicated, the priority should be improving the conditions for early exit.BoundSniper Bot: One large loss can outweigh several clean tradesBoundSniper Bot is a rule-based system that executes TradingView signals in MT5.On July 7, it produced a clean +200 yen result.On July 8, however, a single -418 yen stop loss pushed the day into negative territory, even though the bot won more trades than it lost.The system is consistent because it follows clear rules.But that strength can also become a weakness.When the market changes after the signal appears, the bot may continue holding the original idea without reassessing whether the setup still makes sense.The next step is not only to evaluate whether the initial signal was correct, but also whether the reasoning behind it remains valid after entry.LLMBridgeTrader: Small gains, but four consecutive profitable daysThe most interesting bot this week was LLMBridgeTrader.It lost 232 yen on July 6.After that, the daily results were:* July 7: +76 yen* July 8: +128 yen* July 9: +57 yen* July 10: +16 yenThe gains were not large.Still, the bot remained profitable for four consecutive days.Compared with the other systems, LLMBridgeTrader was better at avoiding prolonged exposure to bad positions.It did not make money by holding one huge winner.It made money by cutting weak ideas before they became expensive.The result was modest, but its ability to preserve capital was the most stable among the four bots.MLScore GF-T4 GB: A promising result on the final dayMLScore GF-T4 GB began the week with several losses, including the closing of older positions.However, on July 10, two short positions reached their take-profit targets and produced +483 yen.That gave a glimpse of the potential behind the machine-learning score.The model may be useful for identifying trade direction.Still, one good day is not enough to draw a conclusion.I need more trades to determine whether high-score setups consistently produce better results.I also need to review whether the current stop-loss and take-profit settings match the price behavior after entry.The real problem was not the entryWhen building an automated trading bot, it is easy to focus on entry accuracy.Add another filter.Use more training data.Change the model.Make the conditions more precise.I have spent plenty of time improving entries.But this week’s results suggest that the main weakness is no longer the entry alone.On July 7, the bots recorded 13 wins and 3 losses.On July 8, they recorded 9 wins and 7 losses.On July 9, they recorded 2 wins and 1 loss.None of those days looked terrible from a win-count perspective.Yet the final weekly result was -3,060 yen.That means the bots are not completely failing to predict direction.The problem is structural.The average gain is too small.The average loss is too large.Until that relationship changes, increasing the number of winning trades will not create stable profits.Knowing when an idea has expiredEvery trade begins with some kind of reasoning.A trend may be developing.A breakout may have occurred.The AI may have produced a buy signal.The machine-learning score may have been high.But the original reason for entering may no longer be valid ten or thirty minutes later.If the market changes and the bot continues holding based only on the original signal, the position becomes attached to outdated information.The goal should not be to defend the original prediction.The goal should be to exit cheaply when the original assumption is no longer supported.A fixed stop loss may not be enough.Time in the trade, fading momentum, acceleration in the opposite direction, conflict with a higher timeframe, and changes in volatility may all be useful exit signals.The system needs a way to reassess the trade after entry.Next week: Improving the exit rulesI do not plan to explain this week’s losses as a simple failure of entry accuracy.The next improvements will focus on:* Exiting before unrealized losses grow too large* Reassessing whether the original setup is still valid after entry* Handling positions that fail to move within a certain amount of time* Separating situations where profits should be extended from situations where they should be secured early* Adjusting the acceptable loss size for each botLosing trades are painful, but they are often the most honest source of information about a system.This week was not only about failing to win.It was about failing to keep the profits that had already been earned.Before trying to increase the number of entries, I need to reduce the damage caused by each losing trade.That will be the main focus of next week’s development and testing. This is a public episode. If you'd like to discuss this with other subscribers or get access to bonus episodes, visit <a href="https:...
Transcribe →