Bot Builder Reference

A visual editor for assembling trading strategies from modular blocks. You configure each block manually — no code is required, but no decisions are made for you.

Each tick, blocks run BY CATEGORY, in a fixed order: signals are checked, filters gate execution, entry rules submit orders, exit rules close positions, and risk limits can override any action. Every block of a category runs — an unconnected block still runs, because the order comes from the category and not from how you wired it.

Every block belongs to a category: Signal, Filter, Entry, Exit, Sizer, or Risk. The category determines how blocks combine (OR vs AND) and WHEN they run — blocks execute by category, not by the order you connected them in.

A named container that organizes related blocks visually. Groups have no effect on trading logic — they exist solely for readability.

Splits capital across child branches according to a weighting scheme. Supports equal, specified percentage, inverse-volatility, and custom modes.

Defines which symbol(s) a branch targets. Attach one or more assets to scope signals and orders to specific instruments.

Names the crypto pairs a bot may trade, the way Asset names equities.

Names the ETFs a bot may trade.

Points the bot at a saved watchlist, so the symbols it trades are whatever that list contains at the time.

Builds the universe from a filter rather than a list - market cap, sector and volume - so the symbols traded change as the market does.

Caps how many symbols from the universe are actually traded on a cycle, and decides which ones.

Selects a single crypto pair, for a bot built around one instrument rather than a set.

Describes the option legs a bot trades - the contracts, not the underlying.

Routes execution down one of two branches based on a boolean condition. The 'if' branch runs when the condition evaluates to true; the 'else' branch runs otherwise.

Multi-branch decision node. Routes execution to one of N cases based on a value or expression result.

Compares two values or indicator outputs and produces a boolean result. Supports >, <, ==, !=, >=, <= operators.

Pauses execution for a set duration or restricts execution to specific times. Adds time-based constraints to strategy logic.

Relative Strength Index — momentum on a 0–100 scale. Fires when RSI is below your threshold (oversold) or above it (overbought).

Where price sits inside its recent high–low range, 0–100. Fires when %K crosses your threshold.

Commodity Channel Index — how far price has deviated from its own mean, unbounded and typically read between −100 and +100.

Momentum on a −100 to 0 scale. −80 and below is conventionally oversold, −20 and above overbought.

Simple Moving Average — the arithmetic mean of the last N closes.

Exponential Moving Average — a weighted mean that favours recent bars.

Fires on the bar where the fast moving average crosses the slow one — the classic trend-change signal.

Whether price is above or below its own moving average. A filter, not a signal — it gates entries rather than proposing them.

The difference between a fast and a slow EMA. Above zero means the fast average leads.

Fires when the MACD line crosses its own signal line — a shift in momentum rather than in price.

Average Directional Index — how strong the trend is, 0–100, regardless of which way it points.

Average True Range — typical movement per bar, in the instrument's own price units.

A moving average with bands a number of standard deviations above and below it.

Standard deviation of price over the window — raw dispersion.

An exit that closes the position when price falls a multiple of ATR below its high — a stop that widens in volatile conditions.

Compares the current bar's volume against its own moving average — a way to require unusual participation.

Volume-Weighted Average Price. Price above it is conventionally read as strength, below it as weakness.

Closes the position once it is up a set percentage from entry.

Closes the position once it is down a set percentage from entry.

Fires when the MACD line crosses above or below the signal line. Based on the difference between a fast and slow exponential moving average.

Scans for divergences between price action and the RSI oscillator. A bullish divergence occurs when price makes a lower low but RSI makes a higher low; bearish divergence is the opposite.

Outputs a signal when price closes beyond the upper or lower Bollinger Band. Optionally requires above-average volume as confirmation.

Fires when multiple moving averages converge within a configurable threshold. This condition sometimes precedes a directional move, but may also resolve sideways.

Flags when current volume exceeds a configurable multiple of the average volume over a lookback period. Optionally requires a directional price move.

Restricts trading to specific hours, days, or sessions. Blocks signal execution outside the defined time window.

Requires minimum volume before allowing trades. Intended to filter out thinly-traded conditions where order execution may be poor.

Gates trades based on a volatility measurement (ATR, realized vol, or implied vol). Passes or blocks based on whether volatility is above or below a threshold.

Classifies the market as trending up, trending down or going sideways, and only lets entries through in the regimes you allow.

Submits a market order that is typically filled quickly but at a variable price. The fill price depends on the current bid/ask spread and available liquidity.

Places a limit order at or better than a specified price. Offers price control but the order may not be filled if the market moves away.

Closes the position in up to three stages as profit accumulates. Each level has a target, as a % gain over entry, and a size, as a % of the original position.

Closes the position when loss exceeds a defined threshold. A common pattern for per-trade loss caps in automated graphs.

A dynamic stop loss that moves with price in the favorable direction but does not move back. If price reverses by the trail amount, the position is closed.

Builds the position in stages instead of all at once. Each stage is placed on a later cycle, only once price has moved in your favour by the configured increment.

Closes the position after a set number of bars, or at a time of day, whether it is winning or losing.

Allocates a fixed percentage of account equity to each trade. The simplest sizing method.

Adjusts position size inversely to recent asset volatility. Trades smaller when volatility is high and larger when volatility is low.

Calculates position size based on estimated win rate and payoff ratio using the Kelly formula. Requires reliable historical estimates to be meaningful.

Enforces hard limits on drawdown, daily loss, open positions, and total exposure. This block is required on every bot and cannot be removed.

Measures how far the account has fallen from its own high-water mark and reduces or stops trading as that gap widens.

Stops the bot holding several positions that are really the same bet, by limiting how correlated open positions may be and how much may sit in one sector.

Caps how much of the account may be in the market at once - gross, net, long and short - and can cut that cap when volatility rises.

Selects a market-data provider (Yahoo Finance, connected broker, Finnhub, Alpha Vantage, Polygon.io, or a custom HTTPS endpoint), timeframe, history depth, and how symbols resolve—then feeds downstream logic on the canvas.

An LLM gate on entries. It reads the evidence the blocks wired into it provide, together with your instruction, and answers yes or no with a confidence score. It is a FILTER: it can veto a trade another block proposed, and can never start one.

Fetches data from an external HTTP API and makes it available to other blocks in the strategy. Supports REST endpoints with custom headers.

A true/false decision you write. The value of the last line on the most recent bar decides whether the block fires.

A named series computed from your own code. It decides nothing on its own — wire it into another block to make its name available there.

A deployable configuration generally requires signal coverage, a single active entry specification, at least one exit specification, a position-sizing rule, and risk-management nodes. The in-application panel enumerates the precise messages emitted when any required role is absent.

Numeric and enumerated parameters are validated against documented domains; required fields must be non-null.

Advisory messages for graph topologies that execute but may diverge from single-active-node conventions.

Begin with a minimal strategy: one signal, one entry, one exit, and a fixed sizer. Add complexity only after establishing a baseline through backtesting.

Never deploy a strategy to live trading without first backtesting it on historical data. Look for consistent behavior, acceptable drawdown, and sufficient sample size.

Set your max daily loss, max drawdown, and max position count before tuning any signals or entries. Risk limits define how long you stay in the game.

Strategies with many tuned parameters can fit historical data closely but fail on new data. Fewer, more robust parameters tend to generalize better.