You bring the strategy.We bring the other 95%.
Describe it in chat and the agent writes the code. Tenor backtests it, deploys it next to Hyperliquid in Tokyo, and risk-screens every order — around the clock.
Your strategy in the middle.
Production plumbing all around it.
Every Hyperliquid bot rebuilds this ring from scratch. On Tenor it's already built.
Backtesting
Replay the same strategy over historical candles — no code changes between backtest and live.
Market data
Live mids, funding, books, balances, and positions — normalized into Context, shared across strategies.
Candles & history
Deep OHLC history, ingested and served for both backtests and live triggers.
Execution & signing
EIP-712 signing, price/size rounding, idempotent placement — against a scoped key the strategy never sees.
Your strategy
A handful of callbacks the agent writes from your chat — when to buy, when to sell, when to sit out.
~5% of the work · 100% of the edgeRisk gate
Notional, position, leverage, and loss-limit caps on every intent — risk-reducing orders always pass.
Deployment
One click from draft to a dedicated VM in Tokyo, co-located with Hyperliquid for single-hop execution.
Crash recovery
The orchestrator supervises every engine — crash → respawn or safe unwind, reconciled from the exchange.
Observability
Live PnL, positions, and fills; every run recorded and queryable, derived from the exchange.
None of the outer ring is your edge. It's the cost of entry everyone pays before testing a single idea. Tenor pays it once, so your time goes to the square in the middle.
From an idea to live capital,
without leaving the chat
Describe it in chat
The agent writes your strategy and surfaces its tunable parameters as a live panel.
Backtest & tune
Replay over historical candles in the browser. Adjust by chatting; code and results update together.
Run
Save a version and deploy in one click — a dedicated VM co-located with Hyperliquid.
Analyze
Live PnL, positions, and fills on the chart — every run recorded and queryable, derived from the exchange.
A strategy is a handful of callbacks
The agent writes your strategy as a few small callbacks — on_candle_close, on_funding, on_fill — each a near-pure decision from market state to intent.
Small enough to read in one sitting, small enough to trust with capital. And because backtest and live run the same callbacks, what you validated is exactly what trades.
def on_candle_close(ctx: Context, candle: Candle) -> list[Intent]: """Buy dips below the 4h VWAP, exit as price reverts.""" z = vwap_zscore(ctx.candles) if z <= -ctx.config.entry_z and not ctx.position: return [buy(ctx.symbol, usd=ctx.config.size)] if z >= 0 and ctx.position: return [close(ctx.symbol)] return [] def on_funding(ctx: Context, funding: Funding) -> list[Intent]: """Exit if the funding carry turns against the position.""" if ctx.position and funding.rate > ctx.config.max_funding: return [close(ctx.symbol)] return []
Market data + state
Book, candles, funding, positions, fills — a read-only Context.
The callbacks
Each trigger runs your callbacks; they return a list of Intents.
Risk gate
Screens every intent; cancels and closes always pass.
Executor → Hyperliquid
Round to tick, sign, submit. Fills return as the next cycle's on_fill.
The same engine runs
our own market maker.
Before it ran anyone else's strategy, it ran ours — same backtester, same execution stack, same risk gate.
Tenor's market maker, to date
Built by the team behind Stride.
Bring an idea.
We'll run the rest.
Describe your first strategy in chat and watch it go from a sentence to live capital.
From a sentence to live capital