Start
What is Structure?
Structure is a product for building, validating, evaluating, and deploying automated trading strategies. It gives strategy teams a single place to express trading logic, test that logic under recorded assumptions, connect supported venues, and operate selected revisions through live deployments.
The product is designed for the full path from a trading idea to a running strategy:
- Turn an idea into explicit strategy logic.
- Save meaningful revisions instead of losing changes in an informal notebook or script.
- Run backtest jobs and paper deployments before using real capital.
- Connect supported trading accounts when you are ready for live operation.
- Monitor positions, holdings, balances, deployment status, and account state from the same product surface.
Structure does not make trading risk disappear. It makes the workflow more inspectable, repeatable, and operationally disciplined, so you can understand what a strategy is meant to do, which version is being evaluated, and which account or simulator path is being used.
Why teams use Structure
Section titled “Why teams use Structure”Automated trading work usually spans several disconnected jobs: research, strategy definition, parameter tuning, simulation, deployment, venue integration, monitoring, and operational troubleshooting. When those jobs live in separate tools, it becomes harder to answer basic questions:
- Which exact strategy revision produced this result?
- Which inputs, thresholds, and state transitions were active at the time?
- Did the backtest job and live deployment use the same strategy definition?
- Which account, venue, instrument, and Strategy Variable values were selected?
- Was the result affected by simulator assumptions, missing data, fees, slippage, or latency?
Structure is useful because it keeps those questions close to the product workflow. A revision is not just a note about an idea; it is the versioned strategy definition that can be validated, compiled, evaluated, compared, selected for deployments, and tied back to the results it produced.
That matters when a strategy becomes more than a prototype. As soon as you need to compare variants, explain behavior, share work, connect a real account, or operate the same idea over time, the system around the strategy becomes as important as the strategy logic itself.
What Structure helps you build
Section titled “What Structure helps you build”Structure’s strategy model separates the parts of an automated strategy that are often mixed together in code. That separation is what makes a strategy easier to inspect and reuse across evaluation paths.
You can use Structure to define:
- Strategy graph logic that computes values from market inputs, constants, memory, and derived calculations.
- Source events that decide when graph paths evaluate.
- Labels that expose typed values to state logic and actions.
- State machines that model the strategy’s current intent.
- Target-position actions that map each state to desired exposure.
- Memory slots that carry selected values across evaluations.
- Groups that package reusable logic behind typed inputs and outputs.
- Strategy Variables that let you supply run-specific values without changing the saved revision.
This lets you represent strategies that need clear logic, state, and position intent, from relatively simple threshold-based approaches to more layered strategies with reusable graph components and persistent state. Because source events can be driven by tick-level data, strategies can react to individual market updates as they arrive when supported market data is available. That makes Structure suitable for highly reactive strategies instead of only slower workflows that wait for aggregated bars or manual review.
What Structure helps you evaluate
Section titled “What Structure helps you evaluate”Before a strategy reaches live operation, Structure gives you evaluation paths for understanding behavior under different conditions.
Backtest jobs evaluate a selected revision over a historical time range. They record the revision, selected settings, historical data coverage, simulator assumptions, and result metrics such as PnL, max drawdown, high-water mark, rolling position, trade count, event count, and data completeness.
Paper deployments let a selected revision run on current market data while routing execution intent to the Venue Simulator instead of a live venue. This is useful for observing how a strategy behaves in real time before allowing it to send order activity through a connected account.
These evaluation paths do not produce guarantees. They produce evidence under assumptions, which is still valuable: you can compare revisions, find obvious flaws, understand sensitivity to settings, and decide whether a strategy deserves more work before considering live deployment.
What Structure helps you operate
Section titled “What Structure helps you operate”When you are ready to operate a strategy, Structure helps connect the strategy definition to supported venue accounts.
The live workflow centers on:
- Trading accounts that represent venue accounts connected to Structure.
- Venue authorization and permission scoping where supported by the venue.
- Live deployments that run a selected revision with selected settings and account context.
- The Target Position Executor, which manages order activity to move account positions toward emitted target positions.
- Monitoring views for positions, holdings, balances, deployment status, account state, and health signals.
At this point, a saved revision is tied to a real account, venue, instrument, permissions, and deployment settings. You are choosing the exact setup that will run, not only reviewing how a revision behaved in a backtest job.
What Structure does not handle today
Section titled “What Structure does not handle today”Structure is intentionally clear about its boundaries. The boundary list tells you what Structure can automate today and what you still need to handle outside the app.
Structure does not invent the trading idea or decide that a strategy is worth deploying. Research judgment, market thesis, discretionary approval, and portfolio-level risk decisions remain with you and your team. Exploratory notebooks, external data preparation, unsupported data sources, and unsupported venue or instrument workflows may also remain outside Structure until the selected logic can be represented as a supported strategy revision.
Today, Structure’s public strategy action type is the target-position action. Strategies express desired exposure by emitting target positions, and the Target Position Executor manages order activity toward those targets. Direct order actions are roadmap functionality; when introduced, they will let strategies place, cancel, and modify orders directly for strategies that need order-level control.
Structure also does not replace venue-level risk management. Leverage settings, margin requirements, liquidation rules, instrument availability, and venue-specific account constraints remain venue concerns. You should configure and monitor those settings directly at the venue where required.
Backtest jobs and paper deployments do not perfectly model live markets. The Venue Simulator does not model the full exchange order book, and simulated results depend on recorded data, fill models, fees, slippage, latency, liquidity assumptions, and data completeness. Tick replay is roadmap functionality and is not a current backtest job capability.
Structure is not a custody product, wallet, broker, exchange, or source of financial advice. It does not choose profitable strategies for you, guarantee execution outcomes, guarantee market data completeness, or remove the need for your own review before deploying real capital.
During launch, venue support is also intentionally scoped. Structure is Hyperliquid-first, and the app will show the currently supported venues, instruments, account setup steps, and permission labels as venue support expands.
How the product fits together
Section titled “How the product fits together”You can think about Structure as one continuous workflow:
- Sign in with your wallet and create your Structure account.
- Define a strategy and build its first draft revision.
- Save revisions as the strategy changes.
- Validate and compile a revision so it can be evaluated consistently.
- Run backtest jobs to study historical behavior.
- Run paper deployments to observe real-time behavior through simulated execution.
- Connect trading accounts for supported venues.
- Start live deployments from selected revisions when you are ready.
- Monitor account state, positions, holdings, balances, health signals, and result evidence.
- Create new revisions as you learn, then repeat the evaluation and deployment workflow.
The important idea is continuity. Structure is not only a strategy builder, only a backtest job runner, or only a deployment console. It is the product surface that connects those steps so the strategy definition, run context, account context, and result evidence stay traceable.
