Three layers of strategy, in one system.

A strategy is a C# project of your own: readable source files, not a black box. Aurexion comes with example strategies you can read and change: opening-range breakout, EMA momentum, Donchian breakout, mean reversion, trend following and volatility breakout.

• Indicators: the built-in ones (EMA, RSI, ATR, Bollinger bands, VWAP, opening range and more), ones the assistant writes for you, or your own in C#. Every built-in indicator also works on an extra timeframe.
• An indicator's value never changes after its bar has closed. Only the bar still forming updates, exactly as it would live, so the chart you study is the chart your strategy saw.
• Up to 3 extra timeframes beside the trading one, each with its own indicators: a 1-hour filter on a 1-minute strategy, or a 1-minute signal on a 15-minute one.
• Stops and targets in ticks, points, R, ATR or dollars.
• Take-profit in up to 3 legs, break-even and trailing stops.
• Every build is versioned and never changes. A backtest, a paper run and a live instance stay pinned to the build they started with, until you move them yourself.
• The build checks kit strategies for banned calls and code style before anything runs.

A good trading strategy on the wrong coins still loses. Choosing the coins is a strategy of its own, so Aurexion lets you build it, test it and run it like one.

Universes: the coins you are willing to trade

• A fixed list you choose, or a list built from a rule you write, for example every coin above a daily traded value over a past window.
• A coin sweep can write one for you: the coins where your strategy passed a significance test.

Selectors: which of them to trade today

• Rules you set in the form, or a short expression, such as momentum minus BTC's momentum, top 3, among the liquid coins.
• Your own machine-learning model, trained in Python (see below).
• Each selector is checked and previewed day by day: every coin's score and rank on that day, and which ones were picked.
• Selectors are scored on each past day with only the data known that day, so a backtest can follow one over years.

The portfolio: strategy plus selector

• Set how many coins are picked per day and how many positions may be open at once.
• The data is checked before the run starts, so a gap shows up before it costs you a result.
• The result shows each day's picks with their rank, and marks the run in-sample or out-of-sample.
• There is no profit split per coin, on purpose: it would invite you to keep the coins that happened to win.
• Portfolio risk rules: tail protection and a limit on correlated positions. Both can only make positions smaller.

A combined backtest runs up to 8 portfolios on one account, the way they would trade as sub-accounts. Each portfolio is its own sub-account, so you can trade the same coins with different strategies, or the same strategy on different timeframes, at the same time.

• Each portfolio has its own strategy, build, settings, timeframe, selector or coin list, coins per day and positions at once.
• Give each one a share of the account, and a risk per trade as a percent of its share, dollars per trade, or lots.
• Every morning the account is split again by those shares, and the day's profit and loss goes back to the one account, so it compounds the way a real account does.
• The result shows the whole account's curve and each portfolio's curve, together or side by side, how much each portfolio added, how closely their daily returns move together, and the peak exposure.

On paper and live, several portfolios run at once, one per account. On Bybit, each portfolio can trade on its own sub-account under your main account, with a daily rebalancer that makes the real transfers between them.

Keep the research tools you know. When a notebook finds something, bring it into Aurexion, where it gets the same accurate backtests, the same execution and the same protection at the exchange as everything else.

• A trading idea you found in Python: describe it to the assistant, and it rebuilds it as a C# strategy you can read, backtest on ticks and run live.
• Coin selection you researched in Python: write it as selector rules, or bring your trained model itself. Linear models and scikit-learn gradient-boosted trees are supported.
• A model comes over with one export(...) call at the end of your notebook. The export recomputes your features with the engine's own maths and refuses to write the file if they do not match your training data.
• The engine scores the model itself. Python never runs while you trade.

Strategies, builds and models then live in one place, and every build and model is versioned. No folder of notebooks to keep in step, and no guessing which version produced which result.

• Optimiser. A Bayesian search that prefers broad, stable parameter ranges over a single peak. Each result says whether it is a robust plateau, a soft hill or a spike, with a stability score and a check on whether it could be luck. A full grid and a surface plot are there too. Every evaluation is a real engine backtest.
• Coin sweeps. Run one strategy across the whole coin list, with a significance test per coin, and save the coins that pass as a universe.
• Capacity check. Reruns strategies at increasing order sizes, models market impact and shows where performance starts to deteriorate.

Coming next: Monte Carlo and walk-forward testing, plus a research journal.

The backtester replays the market one event at a time, in time order: every tick, or every 1-second or 1-minute bar. Your strategy reacts to each event the way it would live, with the same code. The Rust engine runs your C# strategy in-process, with no network hop or interpreter in the event loop. Event-by-event backtesting stays fast, even across years of tick data.

It cannot see the future. Anywhere.

• Bars. At a bar's close your strategy sees the bar that just closed, and of the next bar only what has printed up to that moment.
• Indicators. They are fed completed bars only, so no indicator value contains a price from after the decision. A value is never rewritten once its bar has closed.
• The current day and other timeframes. The daily series and up to 3 extra timeframes show completed periods only; the period still forming holds nothing from its future.
• Fills. An order placed at a decision can only fill on prices printed after it, never on a price that already passed.
• Market regime. A regime filter is computed from past bars only.

Each of these rules is in a written audit and pinned by an automated test, so a change that broke one would fail before it shipped.

Other biases it is built to keep out

• Too-good fills. Spread and slippage come from the ticks, even on 1-minute bars. If the market gaps through a stop, the backtest fills at the gap price, then applies slippage and spread.
• Hindsight in coin selection. Selectors are scored on each day with only the data known that day. On Bybit data, daily selection includes coins that were delisted later.
• Cherry-picking. A portfolio result has no profit split per coin, coin sweeps carry a significance test, and runs are marked in-sample or out-of-sample.
• Over-fitting. The optimiser prefers broad, stable parameter ranges, and says when a result is a spike.

Results

• The metrics that matter, the equity curve, drawdown, monthly, market-regime and holding-time tables, and a significance test on the result.
• A trade log with risk multiples and each trade's best and worst point; click a trade and the chart jumps to it.
• Every run is saved with its log. Compare 2 or 3 runs and the settings that differ are marked.

A backtest is a simulation, not a promise.

• Paper trading on live market data, with shared paper accounts so several strategies can size off one balance.
• Every live entry is sent with its stop-loss attached. An entry without a stop is refused before it reaches the exchange.
• Take-profits rest as maker orders one tick inside a protective take-profit, to save fees. The inner order aims to fill as maker, while the outer take-profit remains as a fallback.
• Live on Bybit perpetual futures today. Hyperliquid next

Start on your exchange's demo account. What your own strategy decides is your responsibility.

• Describe an idea and it writes the strategy in readable C#, which you can test, change and keep. It writes new indicators too, when the idea needs one.
• It reads your real backtest results and can start backtests for you.
• Any figure that no run produced is marked as such.
• It uses your own model: a local one on your machine, or your own API key.

• More than 5,000 automated tests across the engine, the strategy framework and the app.
• Integration tests run the framework's order handling end to end: entries, stops, take-profit legs.
• Real backtests are replayed and must match stored results trade for trade: a single coin, a portfolio, and a run started the way the app starts it.
• The rule here: every bug fix comes with a test that fails without the fix, so it stays fixed.