No-code
Visual blocks
Assemble entries, exits, filters and sizing from blocks, or describe the idea in plain language and refine the draft.
Strategy Forge
From idea to governed automation without leaving the platform.
Strategy Forge is where strategies are made on ORBITRA ONE™. Draft an idea in plain language or visual blocks, build it with or without code, prove it against versioned data and stress, then deploy it under policy — with every version on the record.
- Visual blocks
- Python
- Rust
- Trust record
The strategy lifecycle
Every stage writes to the same record.
Evidence accumulates as a strategy advances, and it stays attached to the version it describes.
- 01IdeaNatural language or visual blocks
- 02BuildPython, Rust or no-code logic
- 03BacktestVersioned data and costs
- 04StressRegime and liquidity shocks
- 05PaperLive market simulation
- 06DeployPolicy-bound execution
- 07PublishPrivate, shared or marketplace
Trust record
- Version
- Code hash
- Data window
- Assumptions
- Costs
- Risk limits
- Approvals
- Execution receipts
- Realized behavior
Seven stages in sequence: Idea (natural language or visual blocks), Build (Python, Rust or no-code logic), Backtest (versioned data and costs), Stress (regime and liquidity shocks), Paper (simulation against real-time markets), Deploy (policy-bound execution) and Publish (private, shared or marketplace). A trust record accompanies the sequence, collecting the code hash, data window, assumptions, costs, risk limits, approvals, execution receipts and realized behavior of each version.
Stage by stage
What each stage proves.
- 01
Idea
Start from a sentence or a canvas of visual blocks. The Forge turns the idea into explicit rules that you review, edit and own.
- 02
Build
Express the logic in Python, in Rust or without code. Parameters and dependencies are versioned with the strategy.
- 03
Backtest
Run against versioned market data with fees, funding and slippage applied. The same inputs reproduce the same result.
- 04
Stress
Replay regime shifts, liquidity shocks and correlation breaks through Aegis scenarios before capital is involved.
- 05
Paper
Trade real-time markets without capital, using the same order primitives the strategy will use once deployed.
- 06
Deploy
Bind one version to a Cortex policy and let it trade within those limits, with a receipt for every action.
- 07
Publish
Keep it private, share it with named people or list it in the marketplace, trust record attached.
Historical or simulated performance does not predict future results. Backtests, stress runs and paper trading show how a strategy behaved under stated assumptions, not how it will behave.
Build your way
Visual or in code. One strategy definition.
However you build, the result is the same versioned definition — the logic that was backtested is the logic that trades.
Python
Research in Python
Explore data, test hypotheses and express signal logic in a familiar research language, with dependencies pinned per version.
Rust
Performance in Rust
Write latency-sensitive or compute-heavy logic in Rust, with deterministic behavior from backtest to deployment.
The trust record
Every version carries its own evidence.
The record is written as a version moves through the lifecycle. It is append-only: a change creates a new version instead of rewriting history.
- Version
- A unique identifier for each change to logic, parameters or limits. Earlier versions remain readable.
- Code hash
- A cryptographic fingerprint of the exact logic that ran, tying every result to one build.
- Data window
- The datasets, their versions and the time range used in backtests and stress runs.
- Assumptions
- Fill, slippage, funding and borrowing assumptions, stated explicitly.
- Costs
- Fees, spreads, funding and financing applied to every simulation.
- Risk limits
- The capital, loss, leverage and market limits the version runs under.
- Approvals
- Who approved deployment or publication, when, and under which policy.
- Execution receipts
- Signed records of every order and fill once the version trades.
- Realized behavior
- Real results set against backtest and paper expectations, so drift is visible.
Deployment
Deployment is a grant of authority.
Deploying does not hand a strategy your account. It binds one version to a Cortex policy — capital, loss limits, leverage ceiling, allowed markets, session and expiry — and every order it generates passes Aegis simulation and policy authorization before it reaches ApexMatch.
Teams can require four-eyes approval before a version is deployed or its limits are raised, and any deployment stops with one command.
- One version per deployment, pinned by code hash
- Policy limits enforced outside the strategy’s own code
- A receipt for every order and fill
- Automatic halt when a loss limit is reached
Cortex
- 01ObserveMarket and portfolio
- 02ReasonModel ensemble
- 03ProposeTrade intent
- 04SimulateAegis risk
- 05AuthorizePolicy engine
- 06ExecuteApexMatch
- CapitalMaximum allocation
- LossDaily and lifetime stop
- LeverageInstrument ceiling
- MarketsAllow / deny lists
- TimeSession and expiry
- ActionHuman confirmation
- DataApproved sources
- KillOne-command revoke
Publishing
Keep it, share it or offer it.
- 01
Private
The strategy runs for you or your organization alone, and its trust record stays internal for your own review.
- 02
Shared
Invite named people or teams to read the record or allocate to the strategy, with permissions set per participant.
- 03
Marketplace
List it for subscription or copy allocation. Subscribers see the full trust record; royalties follow published terms, as described in AlphaStack.
Beyond the Forge
Continue the lifecycle.
Bring your first idea to the Forge.
Strategy Forge is part of Orbitra Prime. Access depends on jurisdiction and eligibility.