OANDA Bot Suite

System architecture

Seven specialists, one account

Rather than one bot trading all 28 currency pairs OANDA offers, the suite splits the work by currency. Each specialist watches only the pairs built around its assigned currency, running the exact same strategy logic as its six siblings.

Coordination across processes

Running seven independent processes against one account creates a coordination problem a backtest never sees: two specialists can decide to act on the account at the same instant. The suite runs on Linux and macOS specifically to use POSIX file locking, so specialists queue behind each other for the moment they touch shared account state instead of racing one another.

Operating the suite

A control dashboard, built with Streamlit and reachable only from the machine running it, is where specialists get started, stopped, and monitored. Because a specialist may be holding an open position at any moment, the shared configuration below is designed to hot-reload: a change takes effect on the process's next scan cycle rather than requiring it to be killed and relaunched. That dashboard is a private operating tool and isn't part of this page.

Trade logic

Entry logic: three narrowing gates

Every specialist runs the identical decision funnel; only the currency and pairs change. A trade idea has to clear all three timeframes, largest to smallest, before it's allowed anywhere near an entry.

Stops and targets

The stop is anchored to market structure rather than a flat pip count chosen in advance: it sits a fixed 15 pips beyond the S/R level that triggered the entry. No trade is taken unless its target, the next S/R level out, offers at least a 2:1 reward-to-risk ratio.

That 2:1 floor isn't an arbitrary round number: it sets how often a trade actually has to win before the rule set is net-positive at all, which is worth showing directly rather than taking on faith.

Post-news mode

A separate mode watches for high-impact economic releases and, after the initial spike, looks for a Fibonacci retracement entry into the pullback rather than chasing the move itself.

Risk controls

Risk management: one account, seven processes

The strategy decides when to trade. A separate layer decides how much, and it's built around the fact that seven independent processes are all drawing on the same equity.

Position sizing splits, it doesn't stack

Each specialist risks a fixed percentage of equity per trade, but that equity figure is divided evenly across however many specialists are currently running. Starting a second bot halves each bot's position size rather than doubling the account's total exposure, and the relationship holds for any number running at once:

Account-wide caps

Sizing isn't the only backstop. A handful of limits are checked against the whole account, not each bot's slice of it, so they hold no matter how many specialists are active:

• Open position cap

  A maximum number of simultaneous trades across all seven bots combined, read from OANDA's live position data.

• JPY exposure cap

  A separate, lower ceiling on open JPY-pair trades specifically, enforced the same way.

• Daily loss limit

  Always evaluated against full account equity, never a bot's divided share, so it protects the account as a whole. Crossing it pauses every bot for the day.

• Startup guard

  Starting a bot while positions are already open requires explicit confirmation; the suite never silently begins trading on top of an existing book.

Parameters

Shared configuration

Every specialist reads the same parameter set from a shared config module, built to hot-reload rather than require a restart, since a restart mid-trade would mean momentarily losing track of an open position:

Strategy and risk parameters are shared by all seven specialists; only the traded currency and pair list differ between them.

Self-hosting

Get the suite

There's no public repository to clone yet. What follows describes how the project is actually laid out and what setting it up from scratch looks like, not a download link.

What it needs

Python 3 and pip, on Linux or macOS — the suite coordinates its seven bot processes with POSIX file locking, which Windows doesn't have natively, so Windows users run it inside WSL2. A setup script installs the Python dependencies (the OANDA API client, pandas and numpy for indicator math, Streamlit for the dashboard, and a handful of others) with one command.

How it's laid out

One module per concern, all reading from the same shared configuration:

Config and credentials

Everything reads from that one shared config module at startup, which in turn loads a local .env file that never gets committed anywhere. Three values matter to start: an API token, an account ID, and which OANDA environment to point at.

# copy the template, then edit it
cp .env.example .env

# inside .env
OANDA_API_KEY=your token
OANDA_ACCOUNT_ID=your account id
OANDA_ENVIRONMENT=practice   # or live, once you trust it

OANDA issues practice credentials for free against a fake-money demo account, which is what a first run should point at. Every risk parameter in the table further up is read from that same config module and stays hot-reloadable from the dashboard, so tuning them doesn't need a restart either.

Running it

A setup script installs dependencies; a backtest run against historical candles comes before anything else; then a launch script starts the dashboard on 127.0.0.1:8501 only, and every specialist bot gets started and stopped from its sidebar from there. One more script stops everything, bots and dashboard together, in a single call.

None of that is reachable from this page. As the callout up top says, this write-up doesn't start, stop, or connect to anything — it's a description of what running it yourself would involve.