Build multi-leg options strategies visually. Run them live under a risk engine that
watches every leg and the whole book. Operate a fleet from one console. Every release is certified
against scripted markets first.
Product visualization — the Live Execution strip, as it reads while a session runs.
01 / The suite
Six parts, built as one system.
Build a strategy, test it over history, certify the software before it
ships, run the fleet, read every session back.
TalgorSB Platform
Multi-leg options, without code.
Design the strategy; a risk engine runs it live in your own account.
Legs, strikes, expiries and lots, set visually.
Per-leg and overall stops, targets and trailing.
Overnight strategies; sessions resume after a restart.
Backtest suites
One strategy, every version of it.
Give the parameters you want to test more than one value and run every combination.
Cases run in parallel; long tests split by month.
One comparison workbook per run, sortable.
Around 120 metrics per case.
SPT Certification
Rehearsal, not backtest.
Every release certified by the same code that trades.
Real engine against scripted price scenarios.
Machine-checked PASS or FAIL.
CI tiers from smoke to weekly.
Remote Launcher
A fleet from one console.
Built for tens of machines and hundreds of sessions a day.
Planner schedules rollouts with readiness checks.
Live fleet view with per-session drill-down.
Performance workbooks and an issues report.
Session Analyser
Every session, readable end to end.
Leg by leg, event by event — live or after the close.
Leg-wise P&L with entry and exit markers.
Momentum hunt targets where the strategy waited.
Option chain at any event on the chart.
Operations backbone
Install, roll back, explain.
Every machine on a known version, every error explained.
Install or roll back from inside the app.
The installer removes old versions itself.
Graded errors; every defect reference opens a card.
02 / Build
Draw the strategy. Skip the code.
A strategy is a set of legs: pick the underlying and the expiry, then set each leg's strike or
offset, its lots and its protection. Save it, export it, move it between machines.
Legs, strikes, offsets, expiries, lots per leg — all configured visually.
Entry styles — scheduled times, momentum hunts that wait for direction, staggered re-entries.
Per-leg protection — Stop Loss, Take Profit and Trailing SL, enforced all session.
Overnight (BTST) strategies alongside intraday, with a timed square-off rule.
Product visualization — a four-leg strategy as it is configured, not coded.
03 / Backtest
Test the strategy. Then test every version of it.
Run a strategy over history from the Backtest tab, or headless from a command line. Give the
parameters you want to test more than one value and TalgorSB generates and runs every
combination — a search of a strategy's parameter space.
Sweep what you choose to vary — strikes, stops, targets, re-entries, entry and exit times.
Runs in parallel — across workers, with long tests split by month and merged back.
One comparison workbook per run — a row per case, sortable in the app.
Around 120 metrics per case — including the exit reason behind every trade.
The backtest runs the same strategy code that trades. Same risk manager, same leg
selection, same parameter file — so a strategy moves from the Backtest tab to the Live
tab unchanged.
A backtest is not a certification. It asks how a set of parameters would have behaved
over history; SPT asks whether the software itself is correct.
You supply the market data. TalgorSB reads a 1-minute bar folder you provide, and
backtest P&L is gross — fees and slippage are applied afterwards, in the Analysis tab.
Product visualization — one generated suite, compared case by case; every name carries its own parameters.
04 / Certify
The code that trades is the code under test.
SPT — Simulated Paper Test — boots the real engine and the real algorithm in live mode
against a simulated brokerage fed scripted prices, and returns a machine-checked PASS / FAIL
report. Every release passes it before shipping.
CI tiers run continuously — smoke, hourly, daily, weekly.
SPT Studio — a desktop GUI to build suites, watch runs, explore results.
Weekend-proof — the simulated brokerage trades outside market hours.
Process visualization — the same code that trades,
run against scripted markets, judged by machine before a release ships.
Product visualization — a certification report; the release is gated on it.
05 / Execute
A risk engine that acts. Orders that arrive as one package.
Risk is enforced at two levels: each leg carries its own Stop Loss, Take Profit and
Trailing SL, while Overall Stop Loss, Overall Target Profit and Lock-and-Trail hold the whole
book, with a timed square-off underneath.
Re-entry budgets per criterion, counted live on the strip as RE used / max.
Atomic multi-leg orders on Interactive Brokers — one package, not four races.
Execution quality — live package Net Bid / Mid / Ask, and a spread gate.
Ladder modes — auto, patient or cross, working the entry toward marketable.
Exits never ladder. Every exit takes the direct marketable path — never gated,
never worked.
Product visualization — one entry, worked from mid to marketable, logged step by step.
06 / Operate
Built for tens of machines. Hundreds of sessions. One console.
Remote Launcher dispatches, monitors and controls trading sessions across a fleet. Every run
produces two documents for two audiences: a performance workbook for the desk, and an issues
report for whoever has to act.
Live fleet view — status, P&L, graded errors and execution quality, per session.
Planner — schedule a rollout days ahead, with readiness checks: machine online, capacity, sanity.
Fleet performance workbook — every session's P&L, margin and fees, subtotalled by machine and strategy.
Issues report — findings graded high, medium and low, each with evidence and an action.
Reports state their own coverage. A fleet health report says how many sessions it
actually read, and flags closed sessions still holding positions.
Product visualization — the fleet view, with the planner staging tomorrow's rollout.
07 / Analyse
Read the session back, leg by leg.
The Session Analyser charts a session while it runs and after it closes. Nothing is inferred
after the fact: every session leaves a complete forensic folder behind it — engine log,
trade log, order events, parameters.
Leg-wise P&L and price paths with entry and exit markers on one timeline.
Momentum hunt targets drawn where the strategy was waiting for direction.
Option-chain snapshot at any event on the chart.
An analysis window, not a report — Excel export belongs to the live views.
Product visualization — one session, read back leg by leg with the chain at any event.
Rigour / How it is built
Software that trades money must not guess.
The differentiator is not a feature; it is what happens after something goes wrong. Every field
incident gets a root-cause analysis, golden-file tests hold the strategy engine's behaviour, and
releases are gated on SPT certification.
Live and paper execution runs on LEAN, the open-source institutional trading engine, hardened
and extended by Creative Mindze for options execution.
“We publish what broke and why to our operators. Our reports state their own coverage.
Software that trades money must not guess.”
Defect register
Every field incident gets a root-cause analysis; the fix ships with a regression test pinned to
the code that failed.
Golden-file regression
On the strategy engine, the recorded behaviour is the specification: drift is a failing test.
Coverage-honest reporting
Fleet reports state how many sessions they actually read. No green all-clear over a blind
spot.
Demo / Contact
See it run on a live market.
The honest way to evaluate trading software is to watch it work. Write to us and we will walk
you through a session end to end.