GTS Trading — Signals, strategies & your own code, on live markets

Expression · Handler · Strategy · Your Code

From a single signal to your own injected strategy code — across Forex, Crypto, Stocks & ETFs (120,000+ symbols).

EXPRESSION

The signal atom — one binary node, Left OP Right (e.g. RSI(14) < 30).
One uniform node, any source — indicator, pattern, price move, account state, AI output, custom code, strategy state or handler result: all the same composable expression type.
30+ element types — indicators, candles, OHLC, quotes, fundamentals, SEC/EDGAR.
Value or condition — use it as a number (a getter) or a true/false signal.
Unary ops & history — MA/EMA/abs, N-bars-back, repeat-within-window.

BUILD ONCE, REUSE EVERYWHERE

PARAMETRIZE · REUSE · COMPOSE

Parametrize once — define an expression with tunable inputs (period, threshold, timeframe) instead of hard-coded numbers.
Name & reuse — save it once and reference it by name from any number of other expressions.
Combine freely — nest named expressions together to assemble higher-level signals, layer after layer.
Ready-to-use structures — turn raw rules into drop-in building blocks: patterns, channels, regime filters, risk gates.
Practically infinite — a small library of reusable blocks composes into an unbounded space of strategies.

HANDLER + STRATEGY

Handler — holds a list of expressions combined by a relation (AND · OR · SEQ), bound to an action: Open/Close · BID/ASK.
Strategy — symbol + position size + SL/TP, wiring open & close handlers.
Position controls — hedging on/off, trailing profit, open N positions on the trend side, dynamic condition-based exits.
Report-only mode — alert without trading via a never-fire helper.
Deploy — run it on a paper/demo account, executed live against the real exchange — real prices & fills, no real funds.

ALERTS

Alert per element — every expression can raise its own alert, on its own.
Not bound to trades — any expression can be alert-only; no position or strategy required.
Toggle on/off — flip alerting per expression without touching the strategy.
Multiple channels — route each alert to one or more: Email · SMS · Telegram · Discord · Web Push · Webhook.

ACCOUNT-AWARE LOGIC

Live-account metrics as operands — balance, equity, open-position count, per-symbol P&L, daily closed P&L & drawdown.
Alert on any metric change — e.g. fire when account balance drops 3%, or daily P&L turns negative.
Gate trades on account state — on demo: open a position only if open positions < 3, symbol PnL < 50 AND positions < 30, or open another when profit rises 2%.
Combine freely — mix account conditions with any signal via AND · OR, exactly like any other expression.
Comprehensive Monitor dashboard — period-based account reporting (daily / weekly / monthly): balances, positions, P&L & metrics, with live monitoring and analysis.

WAYS TO BUILD

Built-in AI generator — describe a signal in words and our in-house model builds the expression for you and assists with your Lua / C++ code, ready to review & save. Runs on a monthly AI-token allowance (larger on higher plans), with prepaid top-up packs.
Visual builder — block-by-block, no code, live preview + tree.
Plain English or formula — type what you want, get an expression.
From JSON or community — paste an expression object, or drop in a ready-made one from the community.
Ask your own agent — point Claude or Codex on your computer at our API: it JSON-builds your idea into a whole strategy and pushes it straight to your account.
Permutation builder — auto-generate and rank strategy variants in bulk.

AGENT-READY

BRING YOUR OWN MODEL

Every form of AI, supported — a built-in on-site model (token budget per plan), a chat assistant, your own external agents, and full remote control via API.
One key-authed API for everything — agents like Codex or Claude build expressions & strategies, generate permutations, deploy, run backtests, and pull signals, stats & reports — all remotely, on your behalf.
Build via JSON — your model emits an expression object from a copy-ready schema prompt; the platform validates & creates it.
Build via plain English — your model describes the signal; a fetchable grammar reference keeps it accurate.
Whole strategies in code — agents ship Lua & C++ logic: submit, test and deploy full custom handlers — not just single rules — through the same API.
Mint a token on the site — generate your API key right here; read / write / control scopes decide what the agent may touch, and it fetches the live API reference itself.
CLI or HTTP — drive the whole platform from any agent runtime — no UI required.

YOUR EDGE

CUSTOM CODE EXPRESSIONS

Create reusable expressions in code — write a signal in Lua or C++; it participates in alerts, handlers, strategies, backtests and other expressions, exactly like any built-in indicator or pattern. You’re not just injecting code — you’re creating a new reusable expression node.
Lua as a first-class operand — inject your logic inside an expression.
Code is itself an expression — your generated or hand-written Lua or C++ builds on the expressions you’ve already made, and the result is itself a reusable expression: name it, run it alongside others, and use it anywhere via AND · OR · SEQ — just like any other expression.
C++ custom handlers — compile a native handler loaded straight into the engine, on the same push-model API.
Expressions are method calls — pick saved expressions from a menu; your code calls each one like a method and gets its value for the current bar (e.g. RSI_14_5min returns its value at that bar) — plus all 30+ expression types: GTSIndicators (200+), candle patterns, price patterns, hour range & more, all selectable from code. No reimplementing indicators.
Whole strategy in code — a full custom handler in Lua or C++, multi-frame & multi-getter, not just one rule.
Open and close, same way — expressions and your code drive exits & risk management exactly like entries. Attach code per operation and write only the logic for each side; sizing, hedging & trailing are built in.
Reviewed before use — your code is deployed and reviewed/approved before it can run live, on your private runtime.

HISTORY ENGINE

10-year, 1-minute data — deep history across 120,000+ symbols: 4k+ crypto, 100k+ stocks & ETFs, 1k+ forex.
Mass runs — up to 100k strategies tested in a single historical run.
Same engine as live — history runs the exact strategy logic, not a re-implementation.
Replay & review — step back through any run’s signals, fills and stats.

DEEP ANALYTICS

Millions of stats per run — every history backtest records far more than P&L.
Per-type channel & trend analysis — e.g. measure every channel’s ending legs and their distribution, or all channels and their durations, for a full statistical view.
Extremes per expression — capture the extreme value each expression reaches, event by event.
You set the logic — define exactly what to measure; the engine aggregates it across the whole run.
Object-state capture — channel-done, trend-done, bars-to-event, extreme values, logged per event.
Derived insight — probability trees, “fires in ~90% of cases”, channel & pattern behavior.

GTS CHARTS

Multi-indicator layout, no limits — stack as many indicators & panes on a single chart as you want.
10-year, 1-minute history — scroll back through deep 1-minute bar data, up to 10 years.
160+ indicators — the full catalog, ready to overlay on any chart.
Any asset, any timeframe — crypto, stocks, ETFs & forex across 120,000+ symbols.
Trade on the chart — place trades by hand on a practice / demo account, with market replay to rehearse your edge.
Expressions & positions on chart — overlay every expression and see your open positions right on the chart.

REAL-TIME

LIVE STREAM & EXECUTION

All asset classes — 4,000+ crypto · 100,000+ stocks & ETFs · 1,000+ forex symbols.
120,000+ symbols — a professional, high-quality real-time data stream with no delays.
Real-time demo trading — run strategies live on Bybit & FXCM demo accounts, with Binance & OANDA next.
Parallel by design — many strategies execute at once, each spanning multiple symbols and timeframes in parallel.
Real exchange or internal — route paper/demo fills against the actual exchange, or simulate them internally — no real funds at risk.
Live-account reporting & alerts — connect a real exchange account for balance, position & P&L reporting and alerts — monitoring only, no real-money trades.
Chart trading & demo — practice on a demo account: replay the market and place trades by hand to test your edge.

Alert routing — per expression, any channel

Flip alerting on per expression and fan each one out to one or more channels. Not limited to trades — any expression can be alert-only: indicators, price velocity, channel objects, fundamentals, history, consensus, repeat-window, composition, crossings, trend objects, Renko bars & OHLC needles.

Expression / alert	Alert	Email	SMS	Telegram	Discord	Web Push	Webhook
`RSI(14) < 30` · indicator	ON		—		—	—	—
`CDL2CROWS 5Min` · candle pattern	OFF	—	—	—	—	—	—
`Close up 2% in 5Min` · price move	ON			—	—		—
`Daily ClosedPNL < 0` · account period	ON			—	—	—
`Balance down 5%` · account-metric drop	ON
`Close +5 ticks / sec` · price velocity	ON		—	—	—		—
`Channel leg 5 end · 30/30 ratio` · channel object	ON		—		—	—	—
`RSI(14)<30 AND MACD↑ AND P/E<15` · 2 indicators + fundamental	ON		—	—		—
`Close higher 3 bars in a row` · history	ON			—	—	—	—
`7 of 10 signals agree` · consensus object	ON		—				—
`EMA(200) > EMA(100) · repeat 3 · 1H` · repeat-within-window	ON		—	—	—
`EMA(50) of RSI(14) < EMA(20) of RSI(14)` · composition	ON		—		—	—	—
`EMA(50) crosses above EMA(200)` · crossing	ON			—	—		—
`Trend.Side=BID · Trend.Length≥40 · Trend.Bars≥12` · trend object	ON		—		—		—
`Renko · last 3 bars up` · renko bars	ON		—		—	—	—
`OHLC.NeedleLen > sliding avg(last 10)` · OHLC needle · sliding window	ON		—	—	—		—

Choose your path

Three ways to use GTS — pick the one that fits.

FULL PLATFORM

Trade

The full builder — signals, strategies, backtests, alerts, paper execution and API automation.

Build expressions, handlers & strategies — visual, NLP or JSON
Built-in AI builder — our in-house model generates expressions and Lua / C++ strategy code for you, token-metered with a monthly allowance included (larger on higher tiers)
GTS v1 API access — agentic AI / CLI jobs can create, update, run and inspect account resources by request
Paper / demo execution on Bybit or FXCM demo accounts (Binance & OANDA next) — live market data
Real-account exchange monitoring & reporting — balances, positions & account metrics (monitoring only, no real-money trades)
Backtest at scale — 120,000+ symbols, up to 100k strategies per historical run on 10-year, 1-minute data
Inject your own Lua or C++ strategy code
Built-in alerts — Email · SMS · Telegram · Discord · Webhook · Web Push
Free tier to start

Open the builder

Alerts only

Same signal engine — notifications, API-driven automation, no trading. Lighter and cheaper.

The same expression engine, alerts only
GTS v1 API for alerts — agents can create signals, manage channels and pull alert history remotely
120,000+ symbols — same universe as Trade (crypto, stocks, ETFs, forex)
Inject your own Lua / C++ signal code
Email · SMS · Telegram · Discord · Webhook · Web Push
No execution — pure signal delivery
Free tier to start

Start with alerts

ON-PREM

Desktop install

For companies — the full GTS engine on your own hardware, with local agentic automation. Limited seats · by request & approval only.

Full GTS desktop runtime, on-premises — full capabilities, no platform limits
Local Job Center CLI — fully agentic jobs for desktop account operations, orchestration and reporting
Real execution venues + real-account monitoring & reporting
Unlimited history & replay — tick data 20+ years back, bounded only by your own data
No caps on alerts, strategies (history + real) or expressions — limited only by your machine & data
Lua / C++ custom code injection & dedicated infrastructure
Limited seats · dedicated installation & white-glove support

Request installation

Trading ideas into
running strategies.