TradeOS: an operating environment for algorithmic trading
Build, test and execute strategies across crypto perpetuals, prediction markets and sports markets — on a runtime designed for adversarial, real-money conditions.
TradeOS runs on Juggernaut Cloud, the same process-driven runtime that powers every other Juggernaut product. Access is currently granted by request.
Why build a trading product on an application runtime?
TradeOS is the first vertical proof that a process-driven, AI-native application runtime can operate safely in an adversarial domain where mistakes cost real money.
Markets are the hardest environment we could choose. Every input is contested, latency matters, and an incorrect assumption is not a bug report — it is a loss. If the runtime is safe enough for self-custodied capital, the same runtime is safe enough for any operational domain: supply chain, finance operations, compliance, or anything else where a wrong automated action has a real cost.
Secure, sandboxed trading apps
Install and run specialised trading applications inside a locked-down environment. Every capability — market data access, wallet signing, order execution — must be explicitly approved. No application can act beyond the permissions it has been granted, so capital is protected by design rather than by trust.
Market data access
Read permissions are scoped per application and per venue. An app sees the feeds you approve and nothing else.
Wallet signing
Signing is a distinct, separately granted capability. An application that analyses markets does not automatically get to move funds.
Order execution
Execution is granted explicitly and bound to the strategy it was approved for, with the runtime enforcing the boundary.
Enforced at the runtime
Permissions are checked by the runtime, not by the application. An app cannot widen its own access.
Deterministic strategy engine
TradeOS ships a purpose-built strategy language. Write, backtest and deploy multi-venue strategies with risk controls, position-sizing rules and stop-loss logic built in — and have them behave the same way when real money is on the line.
Purpose-built strategy language
Positions, venues, risk limits and order lifecycle are first-class concepts — not variables in a general scripting language.
Risk controls built in
Position-sizing rules, stop-loss logic and exposure limits are part of the strategy definition, not an afterthought.
Identical signals, simulation and live
Strategies produce the same signals in simulation and in live trading, eliminating the backtest-fantasy problem.
Multi-venue by construction: a single strategy can read and act across crypto perpetuals, prediction markets and sports markets without a separate integration per venue.
Self-custodied, local-first operation
Strategies, wallet keys and performance records are encrypted and stored locally by default. Nothing touches a remote server unless you explicitly choose to deploy or sync. You keep custody of both your capital and your intellectual property.
- Wallet keys are stored encrypted on your own machine.
- Strategy code and performance records stay local until you decide otherwise.
- Deploying or syncing is an explicit action, not a default behaviour.
Who this matters to
Traders who do not want their positions, keys or strategy logic sitting on someone else's infrastructure.
Firms whose strategies are the asset, and who cannot accept a vendor holding a copy of them.
Teams that treat custody of capital and IP as a precondition rather than a preference.
Native Juggernaut Cloud integration
TradeOS is bidirectionally wired into the Juggernaut Cloud orchestration platform. Signals flow in, structured records flow out, and both directions are machine-readable.
Every strategy run, backtest and automation lands as a Process-Driven Application — an interactive, auditable record your team can inspect and act on, not a log file.
Research feeds execution
AI research agents, sentiment pipelines and multi-step workflows running in Juggernaut Cloud feed signals directly into active strategies. The output of reasoning becomes input to execution without a manual hand-off.
Every run is an auditable record
Every trade, backtest and automation run is written as a structured, auditable record that agents can analyse and act on. That closes the loop between AI reasoning and real-world execution.
Built for systematic operators
Independent systematic traders
Traders running their own strategies who want one environment for writing, backtesting and executing across venues — without handing custody to a platform.
Proprietary trading firms
Desks that need sandboxing between applications, explicit capability grants, and strategy code that never leaves their own infrastructure.
Teams needing auditable automation
Groups that must show what ran, when, and under what rules — with a structured record behind every automated decision around capital.
Five use cases, five real screens
These are TradeOS screens, not mock-ups. Each one is a different job put to the same runtime — same process model, same audit trail, same custody.
Read the regime before you size anything
One screen for macro: a market health score, the KPIs underneath it, and the raw prints it was computed from. Every number names its source and the scoring formula is printed on the panel — it is a transparent read of the environment, not a buy or sell signal.
- Health scored from equities momentum, volatility, the yield curve, rates, crypto appetite and safe-haven behaviour
- Raw inputs shown alongside — Fed funds, 2s10s, VIX, S&P, gold, alt breadth
- Rates and inflation pulled straight from FRED
Interval trading driven by a registered process
The deck holds one slot per market. Each slot names its venue, symbol and interval, then attaches the Juggernaut process that produces the decision — so what runs, where, and how often is configuration rather than a custom integration.
- Size each slot by a fixed dollar amount, a token count, or a percentage of equity
- Output designation separates the DSL strategy, the execution JSON and the written rationale
- Run now, schedule, or auto-execute — decided per slot
Yes/No markets, with the signal state on screen
A scalper running on a Polymarket Up/Down market. The screen shows the price to beat, the live price, the time left in the current cycle and the read it has landed on — and it runs dry first, so the whole loop executes without risking capital.
- Cycle countdown and signal state, so you can see why nothing traded
- Both sides of the book quoted before anything is placed
- Dry run mode for a full rehearsal
Matchup analytics, then straight into an algo
Game Center lines up the slate, then opens a matchup with team analytics side by side and full player lineups with per-player EPA. The same screen builds the algo and syncs it to Juggernaut, so research and execution stay in one place.
- Team analytics compared — EPA per play, success rate, explosive rate, red zone and third down
- Full lineups with per-player EPA
- Build Algo, Matchup Edges and Sync to Juggernaut in one place
A bet slip that states the risk before you place it
Chip-based stake selection with the totals written out: what is at risk, what it returns, and what the payout is. The action button repeats the amount, so the size of the bet is never a surprise.
- Chip denominations instead of a free-text amount
- Risk, potential winnings and payout shown together
- The action button carries the amount: place one bet, risk five dollars
Automated trading carries risk, including the risk of losing money. TradeOS provides controls and auditability, not guarantees. Nothing here is investment advice, and nothing here is a promise of performance or returns.
Request access to TradeOS
Access is granted by request. Talk to us about your venues, your strategies and how you want the runtime configured.
Join the TradeOS waitlist
Access is granted in waves. Leave your details and we will reach out when a slot opens for your venue.