How Stingray Works

Stingray is built around artifacts, not chat. A researcher starts with a market thesis in plain language, and Stingray turns it into a typed rule, a replayable backtest, a live alert, and, where supported, a controlled activation path.

Crypto markets are the first surface because venue data, funding, order books, and onchain activity are visible enough to test ideas with less guesswork. That is the proving ground. The larger product direction is market infrastructure as traditional finance moves onto onchain rails.

1. Resolve the market

Stingray first resolves the entities inside a request: assets, venues, pairs, time windows, indicators, funding markets, events, and delivery channels. The resolution step matters because “ETH funding turned positive after a CPI surprise” is not a keyword search. It is a structured question about assets, data sources, and time.

The same data plane powers Tokenpedia, market news, strategy guides, and live alerts, so the answer can link back to the underlying market context instead of producing a detached summary.

2. Translate the thesis into a typed rule

The output of a request is a rule you can inspect. For example, a plain-English idea such as “alert me when BTC funding is high and price breaks the 4h range after major macro news” becomes a typed condition with explicit signal blocks:

• Market: BTC perpetuals on supported venues
• Filters: funding, price range, volume, and event window
• Trigger: the exact condition that must become true
• Delivery: where the alert should go
• Audit trail: what data was used and how the rule was interpreted

The goal is to make the trading strategy concrete before anyone relies on it.

3. Backtest before activation

Before a rule goes live, Stingray can replay it against historical data and produce a backtest card. The card is the artifact: trigger count, win rate, drawdown, equity curve, sample trades, and the assumptions used during the replay.

That makes a strategy easier to reject. If the backtest only worked during one regime, fired too rarely, or relied on an impossible execution assumption, the user should see that before turning the rule on.

Related examples:

• Backtest a funding-rate and macro-event strategy
• Turn a plain-English strategy into a rule

4. Monitor live conditions

When a rule is activated, Stingray monitors the same typed condition against live market data. Alerts can combine price, funding, technical indicators, news impact, and onchain activity rather than depending on a single threshold.

This is why the workflow is different from a generic price alert. The alert inherits the same rule and context that were used during the backtest.

5. Activate through a trust ladder

Execution-adjacent workflows follow a trust ladder:

• Notify: send the user a live alert when a rule triggers
• Preview-confirm: prepare the suggested action and require explicit approval
• Auto-execute: only where supported, explicitly enabled, and policy-bound

The default stance is proof before capital. Stingray does not assume a rule should trade just because it fired.

What “onchain rails” means here

Onchain rails do not mean every market participant is a crypto trader. They mean market workflows can use public settlement, transparent assets, programmable accounts, and richer data exhaust. Crypto is the first market where those properties are already visible enough to build against.

That matters for traditional finance because the same workflow shape applies as more assets, collateral, and settlement processes move onchain: state the thesis, resolve the data, test the rule, monitor the market, and activate only with the right controls.

What Stingray is not

Stingray is not a custody product, wallet, exchange, or black-box trading bot. It does not ask for private keys. It does not make a strategy good by itself. It makes the strategy explicit, testable, monitorable, and easier to audit.

Why this matters

Most market tools stop at dashboards or generic automation. Stingray is designed for the step in between: turning research into an inspectable workflow that a person or team can reason about before it touches capital.