RFT Ai Trade
In testingCode computes — AI decides.
Three layers of responsibility
Measurement
Computes RSI, MACD, ATR, Bollinger, Donchian channels and Fibonacci levels from real market data — not a single number is invented.
Decision
Direction, entry, stop, profit targets, add-ons, break-even moves and the moment to exit — every trading decision is the model's.
Execution & accounting
Executes the model's orders to the letter, manages the position and keeps exact books — fees, funding, the true break-even price.
The trade cycle
Mapping the field
The model maps the instrument in advance: levels, scenarios, priorities — no orders at this step, no position is opened.
Event at a level
Key levels go under continuous watch; the moment price touches one of them, the system immediately calls the model with fresh numbers.
Market entry only
A pre-written scenario has come true: the level fires once, the decision can't wait, and resting orders fail in breakouts — entry at the current price.
Managing the position
Every profit fix obliges moving the stop to break-even; an add-on is possible only after a fix — and the management loop repeats while the position lives.
Exit and the trade card
A stop, a close order or full profit-taking ends the chapter; the trade card is published at once — including losing ones — and new levels start the next cycle.
Why this works
The model invents no numbers
Every level, indicator and price arrives from the code, computed on real candles, and the instructions forbid the model to contradict the numbers it is given. The most common failure of neural networks in trading — plausible but nonexistent figures — is ruled out here by construction, not by carefulness.
Decision is separated from execution
The model writes its order in machine-readable form; the code executes it to the letter. An order is unconditional: no “if” and no “only above” inside it — conditions live in the scenarios. Between “I think” and “I do” stands a formal boundary that can't be crossed by chance — improvisation at execution is impossible.
Judgment errors are caught by interlocks
A stop set too tight, adding to a losing position, protection on the wrong side — these are systemic classes of error, and each is guarded by code rather than by hope in the model's carefulness. The interlocks are few, but each one closes its class entirely.
The accounting is honest
Fees, funding, real execution prices: break-even is calculated from the actual entry price, not the one mentioned in the text. All trades are published, including losing ones, each at the moment it happens, with a timestamp — nothing is rewritten after the fact.
Safety interlocks
The flagship GT-RFT has no stop-loss as a mechanism and averages the position toward its target — here everything is reversed: a stop stands in every trade, adding to a loss is forbidden, and the interlocks are the boundaries the code holds around the model's decisions.
- Minimum stop distance: a stop set too tight is widened automatically — otherwise market noise knocks it out, not an error in the analysis.
- Break-even and add-ons only after a profit fix: adding to a losing position is averaging down, and it is forbidden by construction.
- Add-on side: for a long, only below the market; for a short, only above — an order from the wrong side is rejected.
- The actual entry price is stored separately and is never rewritten by the model's text — if they diverge, the original value stands.
- Exact break-even: the model names the level, but the code supplies the number — entry plus fees plus accrued funding, the trade's true zero.
Questions about the strategy?
Write to us — we'll answer questions about the mechanics, onboarding terms and risks. No autoresponders, no sales scripts.