Algorithmic trading, built like a trading desk.

Aurexion never sees your strategies. The engine, your data, your research and your exchange keys all live on your machine or server. The assistant runs on your own model, locally if you choose, so nothing about your strategies has to leave the machine.

There is no account with us that holds your work, and no service of ours that receives it. Before launch we publish the full list of every connection the app makes, and how to check it yourself.

Write a strategy once in C#. The same compiled build runs in the backtest, on paper with live market data, and live on the exchange. Builds are versioned and immutable, and an instance stays pinned to the build it was tested with until you move it yourself. What you tested is exactly what trades.

The backtester replays each tick or bar in sequence, so your strategy reacts to market events as it would in live trading. Run it on raw ticks, on 1-second bars or on 1-minute bars. The bars are aggregated from the underlying ticks, first into seconds and then into minutes, while retaining their spread information. Spread and slippage are still simulated closely on 1-minute bars, which keeps results close to a tick-level run.

It cannot see the future: not in the bars, not in the indicators, not in the current day or another timeframe. An order placed at a bar's close can only fill on prices printed after that decision. A written audit backs this up, and each rule is pinned by an automated test. Every rule, one by one.

If the market gaps through a stop, the backtest fills at the gap price, then applies slippage and spread. A backtest is still a simulation, and we say so.

The engine is written in Rust and compiled as one program. It runs your C# strategy in-process, with no network hop or interpreter in the event loop. Research and optimisation run in Julia, a compiled language made for numerical work. Event-by-event backtesting stays fast, even across years of tick data, so you can test an idea and still have time to think about the result.

The execution framework behind Aurexion has traded live for years, in its founder's own trading and in strategies built for clients, before it was ever offered for sale. Every live entry is sent with its stop-loss attached. An entry without a stop is refused before it reaches the exchange.

The stop-loss and take-profit orders rest at the exchange, not on your computer. If your connection drops or your machine restarts, they remain there.

Start on your exchange's demo account. Aurexion is designed around explicit execution rules, but no software can be guaranteed perfect, and what your own strategy decides is your responsibility.

• Take-profits rest as maker orders one tick inside a protective take-profit. The inner order aims to fill as maker, while the outer take-profit remains as a fallback.
• Exits in up to three legs.
• Portfolio tail protection and limits on correlated positions. They can only make positions smaller.

Backtest one portfolio or several at once, then run the same setup on paper and live. Build a universe, the list of coins you are willing to trade, and let a selector pick from it every day. The selector is a set of rules you write, or your own machine-learning model trained in Python. The engine scores the exported model itself, so Python never runs while you trade.

Coin selection is a strategy layer of its own, and so is combining portfolios. A combined backtest can run up to eight portfolios on one account, allowing the same coins to trade under different strategies or timeframes. How the three layers fit together.

On Bybit, each portfolio can trade on its own sub-account, with a daily rebalancer that moves funds between them.

• A Bayesian optimiser that favours broad, stable parameter ranges over a single lucky peak.
• Coin sweeps with significance testing, to flag results that could be down to chance.
• A capacity check for larger accounts. It reruns strategies at increasing order sizes, models market impact and shows where performance starts to deteriorate.

You can also research in Python. The assistant turns trading ideas into C# strategies, and trained coin-selection models can be brought over with a single export call. Research in Python, trade in Aurexion.

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

Developers get C#, a strategy kit with a code style, a build that checks kit strategies for banned calls and code style, versioned builds and a native Linux engine for their own servers.

Describe a trading idea to the assistant, and it writes the strategy in readable C#, including any indicators it needs. You can test, modify and keep the code. It works from your real backtest results and marks any figure that no run produced. It uses your own model: a local one, or your own API key.