SQX Oracle Plugin – Create Strategy from Claude AI

Besides trading strategies, the StrategyQuant community also builds tools that make the rest of the work easier. SQX Oracle, a plugin by community member Clonex, targets one of the most tedious parts of that work: the gap between having an idea and having something you can actually backtest.

You already know what you want — long on a five-minute chart when RSI drops below 30, out after ten bars, protective stop underneath. Saying that out loud takes four seconds. Clicking it together block by block takes considerably longer. SQX Oracle closes that gap: you describe the strategy in plain language, and it hands back a complete SQX file that has already been verified against your own StrategyQuant installation.

Cosa fa

SQX Oracle does one thing, and does it well:

• Plain language in, a real strategy out. Not a template with empty fields — a complete strategy with concrete rules, saved as an SQX file.
• Verified before delivery. The plugin loads the generated strategy into your running StrategyQuant installation and confirms it opens correctly. You see the result as a

  Load passed

  status.

• Straight to the Retester. The finished strategy is sent to the Retester, so a backtest is one click away.
• It reads the results back. Ask it to, and it pulls the metrics exactly as they appear in the databank, evaluates them, and suggests what to change next.

What you need

Four things, and all of them must live on the same machine as StrategyQuant:

• StrategyQuant X, with Remote Access enabled — this is how the plugin verifies that the generated strategy loads.
• Pitone — the plugin’s engine runs on it. Nothing else to install.
• Node.js — needed only to install the agent.
• An agent — Claude Code, Antigravity, or Codex. Each has its own installation guide; follow whichever you prefer.

Everything runs locally. Nothing goes to a browser or to the cloud.

Installation is one command

First, switch on Remote Access. Gear icon in the top-right corner of StrategyQuant → Remote Access → enable → save. The plugin will now reach StrategyQuant at a local address. That is the only thing you configure inside SQX itself.

Then run the bootstrap. Extract the plugin folder anywhere on your drive and open its core folder: Plugins → SQX Skills → SQ Strategy. Copy the path, open a terminal,

cd

into it, and run the bootstrap install command with the path to your StrategyQuant installation.

This step is the reason the plugin works as reliably as it does. The bootstrap reads every indicator and building block available in il tuo installation and writes them into a catalogue file. From that point on, the plugin is tuned to your specific version — it will never generate something your StrategyQuant cannot open. When it finishes, the terminal reports how many indicators and rules were loaded.

That’s the whole installation. One command.

Finally, verify it. The plugin ships with a built-in test suite. You don’t need a strategy for it, and StrategyQuant doesn’t even need to be running. Run it, and you should see 36 out of 36 checks pass — confirmation that both the engine and the loaded catalogue are healthy.

From a sentence to a strategy

There is no interface to click through. You drive the plugin through your agent — in this walkthrough, Claude Code, running locally on the same machine as StrategyQuant.

Launch the agent with a single command and start typing. The plugin is already registered with the agent, so there’s no folder to navigate to and no setup to explain: when you ask for a strategy, it knows to reach for its dedicated builder.

A good first move is simply to ask what it can do. It will explain the workflow in its own words — describe a strategy in one or more sentences, it builds a complete SQX file, validates it in StrategyQuant, and covers indicators, entries, exits, stop losses and other rules.

Then describe something simple. Long positions on a five-minute chart, only when RSI falls below 30. Close after ten bars. Add a protective stop loss. Send it to the Retester. One prompt, one Enter.

The plugin builds the strategy, names it, validates it, and drops it into the Retester with a

Load passed

status — every building block valid, the strategy ready to test.

Reading the results — and iterating

From there it’s a normal backtest: pick the engine, pick the symbol (MNQ — Micro E-mini Nasdaq-100 futures), set the timeframe to five minutes, run.

The interesting part is what happens next. The plugin offers to read the results for you. Tell it to, and it loads the metrics from the databank, evaluates them — in this case, an unprofitable strategy — and comes back with concrete suggestions: add a profit target, add a trend filter. It even writes the prompt for the next build so you can simply accept it.

Accept, and the loop starts turning:

• Build 2 — same logic plus a trend filter. Backtest, read, compare against build 1.
• Build 3 — an ATR-based profit target on top. Backtest, read, compare against both previous builds.
• Next suggestions — move to a higher timeframe, or change the logic to momentum.

Each round is measured against the ones before it, so you’re not guessing whether the last change helped. And each round happens without leaving the terminal: idea → strategy → backtest → evaluation → next idea.

In this example, the conclusion was that the strategy simply doesn’t suit this futures market — which is a perfectly good outcome, arrived at in minutes instead of an afternoon.

What it won’t do

Being clear about this matters: SQX Oracle is not a magic box that produces profitable strategies. It does something less glamorous and more useful — it takes the manual labour off your plate.

What stays with you:

• The logic. You still have to come up with the idea. The plugin converts it faithfully into rules; it does not invent an edge.
• The test setup. Instrument, data, position size, trading costs — the plugin can remind you these matter, but it won’t decide them for you.
• The verdict. A strategy that loads correctly and backtests cleanly is not the same as a good strategy. Only robustness testing answers that — and that’s a topic for another video.

La linea di fondo

Stats tell you whether a strategy works. SQX Oracle tells you nothing of the sort — it just removes everything standing between a sentence and a backtest. Describe it, validate it, test it, read it, refine it, repeat. The clerical work is gone; the judgment is still yours.