atjte — ATJ trading engines

Cross-venue arbitrage market making: a crypto leg on an exchange (Kraken spot, Kraken Futures, Coinbase, Binance, Hyperliquid, Lighter) quoted against a CFD leg on MetaTrader 5, with the CFD hedged fill by fill.

Every platform connection goes through a GATEWAY (atjte.gateways): a per-account / per-machine / per-terminal daemon that owns the keys, the sockets, the order transport and a per-bot dead man's switch, and leases them to the bots over loopback. A bot holds no venue key and no terminal login and opens no venue connection of its own.

atjte is the open-source engine and its gateways (MIT). ATJ's strategy control panel is a separate application built on it.

Install

pip install atjte[mt5]             # from PyPI
pip install -e ".[mt5]"            # from a checkout of this repository (editable)

mt5 pulls the MetaTrader 5 terminal API (Windows only; the MT5 GATEWAY is the one process that needs it). ctrader adds the cTrader Open API connector. The Lighter gateway signs through Lighter's own signer library (lighter_library_path, from github.com/elliottech/lighter-python). ccxt and simplefix (the Kraken FIX gateway's codec) are always installed.

The gateways

atjte-gateway --new coinbase_main --venue ccxt --exchange coinbase
atjte-gateway --new kraken_live   --venue kraken          # Kraken FIX (krakenfutures: -DRV)
atjte-gateway --new hl_main       --venue hyperliquid
atjte-gateway --new mt5_main      --venue mt5
atjte-gateway --list
atjte-gateway coinbase_main                                # run it (or: the panel's Gateways page)

A gateway is a folder, <workspace>/gateways/<kind>/<name>/: gateway.json (what it connects to, its accounts, its listen port) and its own gateway.env (the keys — read from that file only). The folders are never tracked; the templates ship in atjte/gateways/templates/. A bot names its gateway's port and account in VENUE_CLIENT_OPTIONS ({'gateway_port': 5650, 'account': 'main'}) and reads the loopback token by NAME from env/.env.

The bot's connectors (atjte.clients.gateway) keep a CCXT instance for the market MATH only, loaded with the markets the gateway hands over; its HTTP entry point refuses, so no call can reach a venue directly. The engine refuses any VENUE_CLIENT / MT5_CLIENT that does not go through a gateway.

What is in the box

Supported exchanges

Five, by their CCXT ids (atjte.venues is the one list; the connectors refuse any other id and the control panel offers only these):

Every exchange trades through its gateway (the table above): the venue's own (Hyperliquid, Lighter) or the exchange's CCXT gateway, and Kraken spot / Kraken Futures may take the Kraken FIX gateway instead. The keys are the gateway's: <ccxt id>_key / <ccxt id>_secret (+ <ccxt id>_password where the exchange needs one) in a CCXT gateway's gateway.env — Kraken's historical kraken_apikey / kraken_secret and kraken_fut_key / kraken_fut_secret. Lighter's key is its API key, not the L1 wallet key: an existing API key (80 hex chars) signs through Lighter's own signing library (lighter_library_path); the Lighter gateway refuses an L1 key rather than let CCXT register a new API key with it. How a CCXT gateway sends orders is its order_transport: auto (the private websocket where CCXT Pro places there, else REST), ws or rest — one path per gateway, never a fallback.

A workspace and its projects

Everything runs inside a workspace: a folder marked by atjte_workspace.json holding strategies/ (the projects), gateways/ (the gateway instances, with their keys), env/.env (the loopback tokens the bots present), data/ and archive/. It is found through ATJTE_HOME, or by walking up from the strategy folder / the current directory to the marker.

<workspace>/strategies/<project>/
    project_settings.py               EXCHANGE_ID, SYMBOL_VENUE, SYMBOL_MT5, MT5_MAGIC, the gateway connectors, overrides
    strategies/<type>/<type>.py       a ~10-line shim: run_strategy(this folder)
    strategies/<type>/strategy_settings_template.py
    strategies/<type>/strategy_settings.py        the live file — LIVE_TRADING + tunables (created on first start)
    strategies/<type>/bot_state.json position_state.json spread_1s.json fill_marks.csv stop.signal logs/

Settings resolve in three layers, the later winning: the engine defaults, project_settings.py (identity — the symbols and the hedge magic, which have no engine default — plus project-wide overrides), the strategy file.

Make a project by hand:

from pathlib import Path
import shutil
from atjte import templates

proj = Path("~/atjte/strategies/my_xaut").expanduser()
proj.mkdir(parents=True)
shutil.copyfile(templates.project_settings_template("perp"), proj / "project_settings.py")   # then edit the identity
templates.copy_strategy_type("perp", "grid_bot", proj / "strategies" / "grid_bot")

Run it (dry run until LIVE_TRADING = True in its strategy_settings.py):

python -m atjte bot <workspace>/strategies/my_xaut/strategies/grid_bot
python -m atjte bot <...>/grid_bot --check        # bind and print what resolved, no connection
python -m atjte migrate <project>                 # convert a project of the older, copied-engine layout
python -m atjte workspace                          # how the workspace resolves

One strategy per process. A start needs its gateways running — the venue's and the MT5 gateway (a bot started first waits for them) — and the loopback tokens in env/.env (ccxt_gateway_token, hl_gateway_token, lt_gateway_token, kraken_fix_gateway_token, mt5_gateway_token; the control panel writes them when it sets a gateway up). No venue key and no MT5 login is ever read by a bot.

Setting names

One spelling since 2026-09-13: the crypto leg is SYMBOL_VENUE on EXCHANGE_ID, sizes are *_UNITS (the base asset's unit — UNIT_LABEL says how to print it), the crypto venue's gates are VENUE_*. A project written for the retired Kraken engines (SYMBOL_KRAKEN, GRID_UNIT_OZ, MIN_KF_AVAILABLE_MARGIN_USD …) still runs — the engine reads the old names through atjte.engines.common.aliases — and python -m atjte migrate <project> renames them in place (--dry-run lists the changes first).

Tests

python tests/run_all.py                   # core, the engine bound to a ccxt / perp / spot project, the gateways — one interpreter each
python tests/ccxt/test_arb_bot.py         # one file (stdlib unittest, no pytest needed)

License

MIT — see LICENSE.