Deterministic risk gate

Know your hedge.
Protect your capital.

DeltaZero is the deterministic risk gate for pseudo delta neutral DeFi positions. It measures hedge drift, net carry deterioration, funding stress, Safety Buffer breach probability, Monte Carlo impairment, and the next action: rebalance, reduce, or exit.

One typed request returns four coordinated reports and a verifiable Risk Envelope. Read only. No price predictions, prediction markets, charting terminal, token intelligence, or trade execution.

Watch Demo ▶Launch Risk Engine →Agent Console ◎Hedge Intelligence ◇
✓ Read only✓ No signatures✓ Deterministic engine✓ Agent payment ready
Illustrative risk dashboardSOL neutral carry
ΔZ / 01
Safety BufferHealthy · 80th percentileBetter than 80% of 1,001 bounded DeltaZero SOL reference configurations.+16 points above the medium-risk warning threshold.
Hedge Drift4.2%Inside illustrative tolerance
Net Carry APY9.8%Illustrative annual estimate
Monte Carlo DistributionIllustrative stress paths
Delta neutral position
↑ Long SOL↓ Short SOL Perp
Near Neutral
Reference context

Illustrative policy cohort—not a ranking of live Hyperliquid accounts.

Inspect cohort ↗

Deterministic risk gate · x402 · live engine

Test the risk gate in 60 seconds.

Submit one pseudo delta neutral position to the same engine used by DeltaZero's API. Compare a tighter hedge policy with a higher carry policy, then inspect the signals that decide whether to rebalance or exit. Payment settles on X Layer via x402.

Manual assumptions · DeltaZero v1 methodology · Results are decision support, not profit forecasts.
ΔZ

One position. Two policy outcomes.

Run the risk gate to inspect hedge drift, carry, collateral, and operator recommendations without connecting a wallet.

Need the complete four-module risk gate?Launch Risk Engine →

Deterministic interpretation

The deterministic risk gate for pseudo delta neutral DeFi

Every supported position passes through the same gate: hedge drift, net carry deterioration, funding stress, Safety Buffer breach probability, Monte Carlo impairment, and a clear rebalance or exit recommendation.

OptimalPreferred range
HealthyAcceptable risk
WatchReview required
DefensiveAdjustment likely
CriticalSafety limits exceeded

Live product workflow

One risk gate. Four coordinated views.

Use the same deterministic decision boundary before a user or agent deploys capital.

01
Strategy Build

Construct the pseudo delta neutral position and target hedge.

02
Hedge-Drift Auditing

Measure drift, net delta, carry deterioration, and capital at risk.

03
Funding Stress Testing

Apply funding, yield, price, collateral, and liquidity shocks.

04
Monte Carlo Sensitivity

Quantify impairment and Safety Buffer breach probability across seeded paths.

Launch Risk Engine →

How it works

Five deterministic steps from inputs to action.

DeltaZero is a decision-support system. It takes the inputs you already know, applies deterministic risk rules, and returns an explicit next step.

01

Input

Users provide the asset, capital, risk tolerance, target style, yield assumptions, funding assumptions, fees, or existing position data.

02

Analyze

DeltaZero evaluates estimated carry, hedge ratio, hedge drift, net delta, collateral resilience, capital at risk, and Safety Buffer.

03

Assess

The deterministic risk engine compares the metrics against thresholds based on risk tolerance, target style, service type, and stress scenario.

04

Decide

DeltaZero returns strategy health, recommended action, Decision Confidence, risk notes, and a recommended structure where applicable.

05

Act

The user or an autonomous agent can use the result to OPEN, WAIT, HOLD, REBALANCE, REDUCE, or CLOSE.

What DeltaZero does

Four risk reports, one deterministic gate.

The four reports are the product. Read-only protocol data, the operator console, and the registry are supporting inputs and controls around that decision boundary.

01

Strategy Build

Builds a pseudo delta neutral strategy from capital, market assumptions, risk tolerance, and target style.

  • Recommended long notional
  • Short notional
  • Collateral allocation
  • Hedge ratio
  • Carry metrics
  • Safety Buffer
  • Action
Run Strategy Build →
02

Hedge-Drift Auditing

Analyzes an existing long, short, and collateral structure for current health and corrective action.

  • Current health
  • Hedge drift
  • Capital risk
  • Safety Buffer
  • Corrective action
Analyze Hedge Drift →
03

Funding Stress Testing

Applies deterministic scenarios such as funding worsens, yield drops, price shock, or collateral pressure.

  • Post stress metrics
  • Post stress health
  • Recommended action
  • Scenario impact
Run Funding Stress Test →
04

Hedge Intelligence

Supplies read-only public position context to the risk gate so hedge drift and capital exposure can be assessed without wallet permissions.

  • Public position discovery
  • Net exposure
  • Hedge ratio
  • Protocol allocation
  • Portfolio verdict
Open Hedge Intelligence →
05

Monte Carlo Sensitivity

Simulates bounded stress paths to measure impairment, hedge drift, negative carry, and Safety Buffer fragility.

  • P95 and P99 impairment
  • Breach probabilities
  • Sensitivity drivers
  • Sample paths
  • Risk-zone verdict
Run Monte Carlo →

Read-only inputs

Protocol data that feeds the risk gate.

Live integrations are read-only. DeltaZero does not request signatures, private keys, approvals, or transaction permissions.

Live read-only integrations

Supported now

Hyperliquid

LIVE

Read-only perpetual positions, margin data, account value, unrealized PnL, and liquidation context through public protocol data.

Aave

LIVE WITH RPC

Read-only supply, borrow, collateral, debt, and health-factor analysis when supported RPC access is configured.

Morpho

LIVE

Read-only market and vault positions through Morpho’s supported public data API.

Hylo Position Health

LIVE · SOLANA

Read-only Hylo exposure health through Solana public RPC. Token quantities and source metadata are live; collateral ratios, pool state, and liquidation state remain unavailable until an official Hylo state source is configured.

Live Funding Rates

LIVE

Real-time Hyperliquid funding rate data with historical lookback across supported venues.

Supporting position input

Live

Hedge Intelligence

LIVE

Read-only wallet position discovery and portfolio risk assessment across supported integrations.

Planned integrations

Roadmap coverage

Pendle

PLANNED

Fixed-yield, PT, YT, and maturity-risk analysis.

Ethena

PLANNED

Synthetic-dollar and hedged-yield strategy analysis.

ChatGPT MCP app

PLANNED

Remote MCP access for supported ChatGPT workspaces through a separate read-only client path.

Claude MCP connector

PLANNED

Remote MCP access for Claude.ai, Claude Code, and Claude Desktop through a separate read-only client path.

Additional Wallet and Protocol Coverage

PLANNED

More networks, assets, protocols, LP positions, and portfolio adapters.

Unsupported positions and unavailable data sources are reported explicitly and are not treated as zero risk.

Where these strategies can be used

Risk gate policies and supported position contexts.

These are input policies and read-only position contexts for the risk gate, not separate trading products. DeltaZero does not execute trades or connect with transaction permissions.

Neutral Yield Carry

Hold or earn yield on the long leg while shorting perpetual futures to reduce directional exposure.

Relevant platformsHyperliquid, OKX, Drift, GMX, Aave, Morpho, Kamino, Kimia

Conservative Income

Lower leverage, larger collateral reserve, tighter hedge, lower capital risk.

Relevant platformsAave, Morpho, Spark, Compound, Silo

Aggressive Carry

Higher capital deployment, higher expected carry, wider risk tolerance, smaller collateral reserve.

Relevant platformsHyperliquid, OKX, Drift, GMX, Ethena, Kimia

Capital Preservation

Principal protection, tight hedge alignment, large collateral reserve, low capital at risk.

Relevant platformsAave, Morpho, Pendle fixed yield, Spark, Ethena hedged products

Docs

Repository documentation and API references.

Documentation links point to the current repository while the MVP remains in active development.

Documentation

The canonical repository README describes installation, architecture, API usage, and limitations.

Repository README ↗

API reference

The FastAPI backend exposes OpenAPI docs at runtime and the codebase mirrors the request/response models.

See the backend service when it is running locally or in deployment.

Why agents choose DeltaZero

Buy the maintained decision contract—not another risk-engine project.

One typed request returns Strategy Build, Hedge-Drift Auditing, Funding Stress Testing, and Monte Carlo Sensitivity without custom parsers, duplicated thresholds, or spreadsheet orchestration.

18.09 msMedian local decision latencyFour reports · 1,000 paths
19.48 msP95 local decision latency50 measured runs
50 / 50Identical normalized outputsFixed inputs and seed
12 / 12Reference-policy agreementExpected action fixtures

Build versus integrate

DeltaZero compared with common alternatives

Measured values are shown only where a reproducible benchmark exists.
MeasureDeltaZeroAd-hoc Python scriptManual spreadsheet
Agent integrationOne typed API or MCP callCustom code, parser, and deploymentHuman-operated workflow
Decision coverageFour coordinated risk reportsDepends on the implementationDepends on workbook design
Measured decision latency18.09 ms p50 · 19.48 ms p95Not benchmarked—no canonical scriptNot benchmarked—human dependent
Repeatability evidence50/50 identical normalized outputsDepends on seed, code, and testsDepends on formula and version control
Policy-case evidence12/12 reference fixtures passedNo shared fixture set by defaultManual review required
Machine-readable contractValidated structured JSONMust be designed and maintainedExport or wrapper required
Operational burdenMaintained thresholds and schemasAgent owner maintains the full stackFormula, input, and handoff risk
What was measured

Local in-process FastAPI execution on 21 July 2026: 5 warmups, 50 measured runs, four reports per call, and 1,000 seeded Monte Carlo paths. Timestamp fields were removed only for repeatability hashing.

What was not measured

Network transit, deployment cold starts, public-protocol fetches, and payment settlement. No synthetic latency or error-rate figures are assigned to scripts or spreadsheets without a canonical baseline.

Reproduce benchmark ↗Inspect raw results ↗

Reference-policy agreement verifies DeltaZero's configured decision rules. It is not a profitability forecast or a measured real-world loss rate.

Agent composability

One risk contract. Any agent stack.

DeltaZero returns a versioned Risk Envelope that agents can consume through REST, MCP, or portable JSON, while protocol integrations plug into a shared read-only adapter registry.

01 · Standard contract

Risk Envelope v1

A stable decision artifact containing action, risk zone, evidence, measures, constraints, and an analysis ID.

Inspect JSON Schema ↗
02 · Extensible ingestion

Protocol Adapter Registry

Hyperliquid, Aave, Morpho, and Hylo implement the same adapter contract. New read-only integrations register without rewriting the analysis engine.

Review adapter interface ↗
03 · Native agent access

MCP + published SDKs

Agents can invoke the complete engine or the Risk Envelope tool directly, with typed npm and PyPI clients for application workflows.

Open production MCP ↗
schemarisk-envelope/v1
actionOPEN · WAIT · HOLD · REBALANCE · REDUCE · CLOSE
boundaryRead-only · human approval required

DeltaZero deliberately does not publish scores on-chain, mint attestations, approve tokens, or execute trades. Composability ends at an inspectable recommendation so another system cannot mistake analysis for authorization.

Agent ecosystem moat

Recommendations become evidence—not disposable API responses.

Strategy Registry is an opt-in memory layer that connects each DeltaZero decision with the outcome an operator later observes, creating a portable evidence trail for safer policy refinement.

01
Decide

Save the recommendation, risk zone, Safety Buffer, and impairment context.

02
Observe

Record whether risk stayed within tolerance, exceeded expectations, or avoided loss.

03
Refine

Surface recurring exceptions before an agent owner changes a risk policy.

Memory contract

Private by default. Portable by design.

  • Explicit user opt-in
  • Browser-local storage
  • Observed outcomes stay distinct from predictions
  • JSON export and import for agent portability
  • No silent threshold retraining
Open Strategy Registry →

Built for Agents

Deterministic, structured risk assessments for agent workflows.

SDK PREVIEWPublished on npm and PyPI

DeltaZero exposes deterministic, structured risk assessments that can be consumed by agents, dashboards, and automated workflows.

TypeScript SDK
import { DeltaZeroClient } from "deltazero-core";

const client = new DeltaZeroClient({
  baseUrl: "https://deltazero-production.up.railway.app",
});

const report = await client.buildStrategy({
  asset: "SOL",
  capital_usd: 5000,
  risk_tolerance: "medium",
  target_style: "neutral_yield",
  long_yield_apy: 14,
  short_funding_apy: 3,
  fee_drag_apy: 1,
});

console.log(report.recommendation.action);

Agent use cases

  • Portfolio automation with structured strategy responses.
  • Dashboards that need deterministic risk results.
  • Offline analysis workflows that call the live API.
npm: deltazero-corewww.npmjs.com/package/deltazero-corePyPI: deltazero-corepypi.org/project/deltazero-core/API documentationdeltazero-production.up.railway.app/docsOKX ASP documentationgithub.com/Teecash96/DeltaZero/blob/main/docs/OKX_ASP_SERVICE.md

Install from npm (npm install deltazero-core) or PyPI (pip install deltazero-core). The SDKs are thin, typed clients around the deployed API.

Why DeltaZero

Trust comes from inspectable decisions, not black-box claims.

DeltaZero is designed for transparent, read-only analysis of user inputs and supported public position data.

Deterministic analysis

The same inputs and configured thresholds produce the same explainable result.

Read-only access

Supported wallet integrations retrieve public position context without transaction permissions.

No trading signatures

Risk analysis never asks you to sign a trade, approval, or protocol transaction.

No custody

DeltaZero does not hold funds, control wallets, or execute the recommended action.

Transparent calculations

Metrics, risk notes, decision drivers, and raw JSON remain available for verification.

FAQs

Common questions, answered directly.

The MVP is intentionally narrow, deterministic, and transparent about its limits.

Is DeltaZero non custodial?+

Yes. The current MVP does not hold funds, connect wallets, or execute transactions.

Does DeltaZero execute trades?+

No. It provides deterministic risk analysis and recommendations only.

Which assets are supported?+

The current MVP supports SOL and ETH.

Which target styles are supported?+

Neutral Yield, Conservative Income, Aggressive Carry, and Capital Preservation.

How is the recommendation generated?+

The backend evaluates carry, hedge alignment, Safety Buffer, capital risk, and service specific thresholds using deterministic rules.

What is Decision Confidence?+

Decision Confidence measures how clearly the current metrics support the recommendation. It is not a measure of profitability or strategy quality.

Are protocol integrations live?+

Hyperliquid, Aave, and Morpho are live read-only integrations. Pendle, Ethena, live funding inputs, and additional coverage remain planned.

Is my data stored?+

No. The current MVP has no database and does not retain submitted strategy inputs.

Can autonomous agents use DeltaZero?+

Yes. The services expose structured API responses that can be consumed by agents, dashboards, or trading workflows.