Δ DeltaZero

Deterministic risk intelligence for pseudo delta neutral DeFi strategies

Build strategies, analyze hedge drift, simulate economic impairment, and assess supported public wallet portfolios through one transparent risk engine.

Live Application · API Documentation · Published SDKs · X

DeltaZero is an open-source, production-oriented ASP for deterministic DeFi risk analysis. It converts strategy assumptions and supported public wallet data into structured metrics, strategy health, recommended actions, risk notes, and decision confidence without claiming to predict markets.

Product screenshots

Live risk-intelligence interface

Methodology, provenance, and support

The live Methodology page documents DeltaZero's formulas, worked Safety Buffer calculation, threshold provenance, model card, impairment model, Monte Carlo assumptions, reproducibility requirements, validation status, data sources, and limitations. Completed Strategy Build, Funding Stress Testing, and Wallet Auditor reports include a visible provenance panel with the source, source snapshot, report time, and data-quality context when available. DeltaZero does not claim historical validation or empirical threshold calibration until a versioned, time-aligned replay dataset is published.

Live MCP server

DeltaZero exposes a standards-compliant, stateless Streamable HTTP Model Context Protocol server at:

https://deltazero-production.up.railway.app/mcp

MCP initialization, discovery, resources, market context, and deterministic tools are temporarily free during listing review:

• build_neutral_strategy
• audit_hedge_drift
• run_funding_stress
• run_monte_carlo
• run_complete_risk_engine — all four coordinated reports in one invocation

The OKX Agent Payments Protocol implementation remains staged. Set DELTAZERO_ACCESS_MODE=paid after the temporary free-access period to restore the existing 1 USDT per-call boundary without changing application code.

The MCP tools call the same Python service functions used by the REST API; formulas and recommendation logic are not duplicated. Tool inputs and structured outputs are generated from the same Pydantic contracts, so compatible agents do not need endpoint-specific response parsers.

Connect locally with MCP Inspector:

npx -y @modelcontextprotocol/inspector

Then use http://127.0.0.1:8000/mcp as the Streamable HTTP server URL.

For product questions, API issues, payment problems, or data-quality reports, use the Support page. Support will never request a seed phrase, private key, wallet approval, admin bypass key, or API secret.

GitHub Actions runs backend tests, frontend lint and production build, and both SDK test suites for pushes to main and pull requests. No production credentials are required by CI.

DeltaZero Risk Zones

DeltaZero classifies completed Strategy Build, Wallet Auditor, Funding Stress Testing, and Monte Carlo reports into five operator-friendly zones: Optimal, Healthy, Watch, Defensive, and Critical.

Risk zones are deterministic interpretations of existing report metrics. They are not trading instructions and do not predict profitability.

The current product includes Strategy Build, Hedge-Drift Auditing, Funding Stress Testing, read-only Wallet Auditor, and Agent Operator Console. It never requests private keys, seed phrases, trading signatures, approvals, or transaction permissions, and it does not execute trades. The backend payment boundary is staged but temporarily disabled for listing review; payment credentials remain separate from any trading or protocol permission.

Why DeltaZero?

Pseudo delta-neutral strategies can look attractive while hiding hedge drift, weak collateral, negative carry, liquidation exposure, or severe scenario losses; DeltaZero makes those risks explicit before a user or agent acts.

DeltaZero is differentiated by:

• Deterministic decisions — recommendations come from documented rules and evaluated thresholds rather than opaque generated calculations.
• One risk language — Strategy Build, Hedge-Drift Auditing, Funding Stress Testing, and Wallet Auditor consistently report health, action, Safety Buffer, risk notes, and Decision Confidence.
• Read-only portfolio analysis — supported public protocol data is analyzed without custody or wallet permissions.
• Agent-ready contracts — FastAPI schemas and local TypeScript and Python SDK packages expose structured responses for dashboards and automated workflows.

Feature Overview

Capability	Status	Description
Strategy Build	Live	Constructs a deterministic pseudo delta-neutral structure from capital, risk tolerance, target style, and market assumptions.
Hedge-Drift Auditing	Live	Evaluates an existing long, short, and collateral structure and recommends corrective action.
Funding Stress Testing	Live	Applies deterministic funding shocks and calculates post-stress risk and scenario-based economic impairment.
Wallet Auditor	Live · Free Preview	Analyzes supported public wallet positions through read-only protocol adapters.
Agent Operator Console	Live · Simulation	Runs a session-only guard loop that detects simulated hedge drift, calls the live audit API, and prepares an approval-gated proposal without claiming trade execution.
Decision Engine	Live	Centralizes carry, hedge, Safety Buffer, capital-risk, health, action, and confidence evaluation.
Economic Impairment Engine	Live	Estimates impairment loss, post-impairment equity, and a non-overlapping loss breakdown.
Agent Payment Gate	Staged · Temporarily Free	The verified 1 USDT X Layer payment boundary remains in the backend and can be restored with DELTAZERO_ACCESS_MODE=paid. All analysis calls are currently free during listing review.
Interactive Strategy Preview	Live	Provides a clearly labelled illustrative simulation on the landing page.
TypeScript SDK	Published · npm	Supplies a typed client through deltazero-core.
Python SDK	Published · PyPI	Supplies a typed client through deltazero-core.
Hyperliquid	Live	Reads supported perpetual positions and account context from public protocol data.
Aave	Live with RPC	Reads supported lending and collateral data when an RPC endpoint is configured.
Morpho	Live	Reads supported market and vault positions from Morpho's public API.

Products

Agent Operator Console

The /agent console turns DeltaZero's structured API into a transparent operator workflow. A user selects risk tolerance and strategy mandate, spawns a session-only guard, and watches the guard compare simulated hedge drift against the configured intervention boundary. When the boundary is breached, the console calls live Hedge-Drift Auditing and displays the returned recommendation. Execution authority remains disabled until a separately authorized and compatible venue adapter is configured.

Agent-in-a-Box example

The executable examples/agent-bot/agent-bot.mjs demonstrates an autonomous monitoring loop: simulated wallet scan, hedge-drift trigger, live audit request, optional agent payment authorization when paid mode is enabled, and a proposal-only rebalance payload. See the example guide for safeguards and run commands.

Strategy Build

The Builder creates a proposed structure from:

• asset and deployable capital;
• risk tolerance;
• target style;
• long-yield assumption;
• short-funding assumption; and
• fee-drag assumption.

It returns recommended long notional, short notional, collateral allocation, target hedge ratio, carry metrics, Safety Buffer, strategy health, Decision Confidence, recommendation, and risk notes.

Supported target styles are:

• neutral_yield
• conservative_income
• aggressive_carry
• capital_preservation

Each style uses a distinct deterministic allocation and threshold profile.

Hedge-Drift Auditing

Hedge-Drift Auditing evaluates a supplied long, short, and collateral structure. It measures hedge alignment, net delta, carry, collateral resilience, Safety Buffer, and capital at risk before returning an action such as HOLD, REBALANCE, REDUCE, or CLOSE.

Funding Stress Testing

Funding Stress Testing evaluates stressed rather than original metrics. It supports deterministic scenario inputs for funding deterioration, yield reduction, price movement, collateral pressure, exit slippage, liquidation penalties, and protocol-loss assumptions.

Its report includes:

• scenario result;
• post-stress metrics;
• post-stress health;
• recommended action;
• Decision Confidence;
• risk notes;
• estimated impairment loss; and
• post-impairment equity.

Monte Carlo Sensitivity Analysis

Monte Carlo analysis runs 100 to 10,000 bounded stress paths across market movement, funding shifts, exit slippage, collateral haircuts, collateral depeg, and protocol-loss assumptions. Its systemic mode uses a configurable correlated Student-t model: collateral depeg severity can simultaneously amplify funding pressure, slippage, and collateral impairment. It reports impairment and post-stress equity distributions, depeg and breach probabilities, percentile outcomes, observed correlation, and ranked sensitivity drivers. These correlations are transparent scenario assumptions, not empirically calibrated forecasts.

Report history and notification handoff

Completed Risk Engine and Monte Carlo reports are saved in the user's browser at /history (up to 25 reports). Users can export JSON or share a computed risk snapshot through email and Telegram. This is local report history and notification handoff—not continuous background monitoring. Unattended alerts still require a future server-side scheduler, durable storage, and opt-in notification subscriptions.

The engine is deterministic when a seed is supplied and reuses DeltaZero's existing impairment, metric, and threshold logic. It is a sensitivity tool—not a price forecast—and it does not source, infer, or fabricate future market data. Builder results and supported Wallet Auditor exposures can be transferred through short-lived browser session storage for simulation.

Key inputs include the current structure, capital, carry assumptions, simulation count, time horizon, seed, and bounded volatility assumptions. Outputs include P50/P95/P99 impairment, expected post-stress equity, Safety Buffer and hedge-drift breach probabilities, negative-carry probability, sensitivity contributions, and up to 50 sample paths.

Wallet Auditor

The Wallet Auditor discovers and normalizes positions available through supported read-only integrations. It aggregates exposure, collateral, debt, unrealized PnL where reliable, hedge alignment, liquidation context, Safety Buffer, capital at risk, and estimated impairment.

The wallet report explicitly distinguishes:

• positions_found
• no_supported_positions
• partial_data
• insufficient_data

No supported positions and incomplete data are terminal assessment states, not evidence of a healthy portfolio. Missing values remain nullable instead of being silently treated as zero risk.

Open the Wallet Auditor to analyze supported public data.

Live Read-Only Integrations

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.

Set ETHEREUM_RPC_URL and ARBITRUM_RPC_URL in the backend environment to enable the configured network access. RPC credentials must never be committed.

Morpho — LIVE

Read-only market and vault position analysis through Morpho's supported public API.

Live integrations are read-only. DeltaZero does not request signatures, private keys, approvals, or transaction permissions. Unsupported positions and unavailable data sources are reported explicitly and are not treated as zero risk.

Architecture

flowchart LR
    subgraph Clients
        WEB[Next.js Web App]
        TS[TypeScript SDK]
        PY[Python SDK]
        AGENT[Agent or Dashboard]
    end

    subgraph API[FastAPI Service]
        PAYMENT[x402 Payment Gate]
        ROUTES[Validated API Routes]
        STRATEGY[Strategy Services]
        DECISION[Deterministic Decision Engine]
        IMPAIRMENT[Economic Impairment Engine]
        WALLET[Wallet Analyzer]
        NORMALIZER[Position Normalizer]
    end

    subgraph Sources[Read-Only Data Sources]
        HL[Hyperliquid]
        AAVE[Aave via RPC]
        MORPHO[Morpho Public API]
    end

    subgraph Payments[OKX Agent Payments]
        FACILITATOR[OKX Facilitator]
        XLAYER[X Layer USDT Settlement]
    end

    WEB --> PAYMENT
    TS --> PAYMENT
    PY --> PAYMENT
    AGENT --> TS
    AGENT --> PY
    PAYMENT --> ROUTES
    PAYMENT --> FACILITATOR
    FACILITATOR --> XLAYER
    ROUTES --> STRATEGY
    ROUTES --> WALLET
    STRATEGY --> DECISION
    STRATEGY --> IMPAIRMENT
    WALLET --> NORMALIZER
    NORMALIZER --> DECISION
    WALLET --> IMPAIRMENT
    WALLET --> HL
    WALLET --> AAVE
    WALLET --> MORPHO

Loading

Frontend

The web interface uses Next.js App Router, React, TypeScript, and Tailwind CSS. It connects to the backend through NEXT_PUBLIC_API_BASE and contains no authentication, wallet connection, transaction flow, database, or client-side calculation engine.

Backend

FastAPI and Pydantic validate requests and responses. Service modules own strategy construction, position auditing, stress testing, wallet analysis, normalized metrics, recommendations, and impairment calculations.

Decision Engine

The centralized engine evaluates carry, hedge drift, Safety Buffer, capital risk, and impairment state. Strategy health, action, summary, risk notes, and Decision Confidence originate from the same evaluated context.

Decision Confidence measures how clearly the current metrics support a recommendation. It is not a profitability forecast or a strategy-quality score.

Economic Impairment

The impairment engine compares pre-stress and post-stress portfolio equity. Short-hedge gains offset long-leg losses where appropriate, while collateral haircuts, exit slippage, liquidation penalties, and protocol-loss assumptions are applied without blindly adding overlapping losses.

This is scenario-based economic impairment analysis, not formal IFRS or accounting impairment.

How It Works

Input assumptions or public wallet address
                  ↓
Validate and normalize the request
                  ↓
Calculate carry, hedge, collateral, and risk metrics
                  ↓
Evaluate deterministic thresholds and scenario impairment
                  ↓
Return health, action, confidence, notes, and structured JSON

The recommendation vocabulary depends on the service:

• Builder: OPEN, REBALANCE, or WAIT
• Auditor: HOLD, REBALANCE, REDUCE, or CLOSE
• Wallet Auditor: HOLD, REBALANCE, REDUCE, or CLOSE when an assessment is meaningful

Published SDKs

DeltaZero includes thin, type-safe clients that call the existing deployed API. They do not duplicate backend calculations.

The TypeScript SDK is published on npm and the Python SDK is published on PyPI under the shared package name deltazero-core. Both packages are also available from this repository and exercised by CI.

TypeScript

Package name: deltazero-core

Repository path: sdk/typescript

npm install deltazero-core

import { DeltaZeroClient } from "deltazero-core";

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

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);

Available methods:

• buildStrategy()
• auditPosition()
• stressTest()
• auditWallet()

Python

Package name: deltazero-core

Repository path: sdk/python

python -m pip install deltazero-core

from deltazero import DeltaZeroClient

client = DeltaZeroClient(
    base_url="https://deltazero-production.up.railway.app",
    timeout_s=10,
)

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

print(report["recommendation"]["action"])

Available methods:

• build_strategy()
• audit_position()
• stress_test()
• audit_wallet()

Agent and dashboard use cases include deterministic pre-trade checks, portfolio review workflows, scenario-risk gates, report generation, and structured inputs to broader orchestration systems. DeltaZero does not execute the resulting action.

API Reference

Live Hyperliquid market context

GET /market/hyperliquid?asset=ETH&lookback_hours=24 returns normalized mark and oracle prices, signed current hourly funding and APY, open interest, 24-hour notional volume, premium when available, and a historical funding summary. The service uses Hyperliquid's public Info API only, with short-lived in-memory caching.

Positive funding means longs pay shorts; negative funding means shorts pay longs. DeltaZero preserves that sign. Funding rates are variable and may change after analysis.

Manual and live Builder modes

The Builder defaults to manual assumptions. Live Hyperliquid mode retrieves public market context while keeping long-yield and fee-drag inputs manual. Because the existing Builder field represents a short-side funding cost, signed market funding is converted centrally: positive market funding becomes income to the short hedge, while negative market funding becomes a cost.

Wallet hedge workflow

Successful Wallet Auditor reports can pass a normalized, non-sensitive exposure snapshot to the Builder through short-lived browser session storage. The Builder calculates a proposed short adjustment for long-dominant portfolios using the configured style and risk target, and the proposed structure can then be handed to Stress Test. These are read-only analytical recommendations: DeltaZero does not request signatures, submit transactions, or execute hedges.

Base URLs

Environment	URL
Local	http://localhost:8000
Production	https://deltazero-production.up.railway.app
Swagger UI	Production API documentation
OpenAPI schema	https://deltazero-production.up.railway.app/openapi.json

Endpoints

Method	Endpoint	Purpose
GET	/	Check the public service root. Free.
GET	/health	Check backend availability.
GET	/docs	Open Swagger UI. Free.
GET	/openapi.json	Read the OpenAPI contract. Free.
POST	/strategy/build	Build and evaluate a proposed strategy. Temporarily free.
POST	/strategy/audit	Audit an existing position structure.
POST	/stress-test/run	Apply a deterministic stress scenario and impairment model.
POST	/strategy/stress-test	Legacy alias retained for SDK compatibility. Temporarily free.
POST	/wallet/analyze	Analyze supported public wallet positions. Temporarily free.
POST	/monte-carlo/run	Run seeded Monte Carlo sensitivity analysis. Temporarily free.
POST	/risk-engine/analyze	Run Strategy Build, Hedge-Drift Auditing, Funding Stress Testing, and Monte Carlo Sensitivity as one coordinated free-preview analysis.
POST	/	OKX.AI-compatible alias for the complete coordinated Risk Engine analysis. A bare review probe returns the documented SOL reference scenario; callers can submit their own full request body.

Temporary free access and staged payments

DeltaZero currently defaults to DELTAZERO_ACCESS_MODE=free. In this mode every REST analysis route and every MCP tool is available without payment so OKX.AI reviewers and the demo editor can exercise the live product end to end.

The production payment implementation remains in the codebase. After listing and demo completion, set:

export DELTAZERO_ACCESS_MODE="paid"

Paid mode uses the official OKX seller middleware. An unpaid request to a protected route returns HTTP 402 Payment Required with a base64-encoded PAYMENT-REQUIRED header. The header is the authoritative payment quote and identifies the network, stablecoin contract, atomic amount, receiver, and supported payment schemes.

The future price is configured with PAYMENT_PRICE_USDT. When paid mode is restored, the primary product flow calls /risk-engine/analyze: one 1 USDT payment returns all four coordinated Risk Engine reports for one submitted strategy. A new analysis is a new paid call. Agent Console, Hyperliquid Live, health, documentation, and OpenAPI remain free.

In paid mode, only the three PAYMENT_* variables produce challenge-only behavior: the server returns the quote but never releases a protected resource. Once all three official OKX facilitator credentials are configured, the submitted payment credential is verified and settled synchronously before the handler runs, and a successful response includes PAYMENT-RESPONSE.

Agent-native payment

DeltaZero does not collect payment or connect wallets in the website. During the temporary free preview, autonomous clients can invoke the API without payment. When paid mode is restored, the OKX Agent Payments Protocol handles the quote, authorization, paid replay, and machine-readable settlement receipt before the backend releases the requested report.

The website remains a read-only product, methodology, and API-discovery surface. Agent clients can inspect the OpenAPI and MCP contracts and run the live analysis tools freely during review.

Unpaid challenge:

curl --include \
  --request POST \
  --url https://deltazero-production.up.railway.app/strategy/build \
  --header 'Content-Type: application/json' \
  --data @builder-request.json

Paid replay after an x402-compatible wallet signs the returned challenge:

curl --include \
  --request POST \
  --url https://deltazero-production.up.railway.app/strategy/build \
  --header 'Content-Type: application/json' \
  --header "PAYMENT-SIGNATURE: ${PAYMENT_SIGNATURE}" \
  --data @builder-request.json

Never construct a payment credential by hand or treat the presence of a header as proof of payment. In challenge-only mode all paid replays fail closed. In settlement mode DeltaZero forwards credentials to the OKX facilitator for cryptographic verification and settlement before returning the protected resource.

Admin Testing

The admin bypass is for owner and developer testing only. Set DELTAZERO_ADMIN_KEY in the backend environment, then send the value in the X-DeltaZero-Admin-Key request header from curl, Postman, or an agent. A correct key bypasses x402 for protected endpoints; a missing or incorrect key follows the normal payment flow.

Never commit this key, place it in a NEXT_PUBLIC_* variable, or expose it in browser code. DeltaZero logs only admin_bypass_used=true when the bypass is used and never logs or returns the key itself.

curl --request POST \
  --url https://deltazero-production.up.railway.app/strategy/build \
  --header 'Content-Type: application/json' \
  --header "X-DeltaZero-Admin-Key: ${DELTAZERO_ADMIN_KEY}" \
  --data @builder-request.json

Builder request body

{
    "asset": "SOL",
    "capital_usd": 5000,
    "risk_tolerance": "medium",
    "target_style": "neutral_yield",
    "long_yield_apy": 14,
    "short_funding_apy": 3,
    "fee_drag_apy": 1
}

Wallet example

{
  "wallet_address": "0x0000000000000000000000000000000000000000",
  "networks": ["ethereum", "arbitrum", "hyperliquid"],
  "protocols": ["hyperliquid", "aave", "morpho"],
  "stress_profile": "standard"
}

Wallet analysis is read-only. Protocol failures are isolated and returned as warnings or errors so unavailable data is never represented as confirmed zero exposure.

Detailed service documentation:

• Wallet Auditor
• Hyperliquid Market Data
• Economic Impairment Engine
• OKX ASP Service
• Project specification

Installation

Prerequisites

• Python 3.11 or newer
• Node.js 20 or newer
• npm

Clone the repository

git clone https://github.com/Teecash96/DeltaZero.git
cd DeltaZero

Start the backend

cd backend
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --reload --host 127.0.0.1 --port 8000

Optional Aave RPC configuration:

export ETHEREUM_RPC_URL="your-ethereum-rpc-url"
export ARBITRUM_RPC_URL="your-arbitrum-rpc-url"

Do not commit RPC URLs containing provider credentials.

The application defaults to the temporary free preview. Set this explicitly in deployment environments for clarity:

export DELTAZERO_ACCESS_MODE="free"

To restore paid mode later, set DELTAZERO_ACCESS_MODE="paid" and configure the receiving address, per-call price, and X Layer network identifier:

export PAYMENT_RECEIVER="0xYourReceivingAddress"
export PAYMENT_PRICE_USDT="1"
export PAYMENT_NETWORK="eip155:196"
export PUBLIC_API_BASE_URL="https://deltazero-production.up.railway.app"

To enable paid verification and settlement, additionally configure the complete official facilitator credential group:

export OKX_API_KEY="your-okx-developer-api-key"
export OKX_SECRET_KEY="your-okx-developer-secret"
export OKX_PASSPHRASE="your-okx-developer-passphrase"

In free mode, payment configuration is not loaded and every analysis route is released without a challenge. In paid mode, all three PAYMENT_* variables are required. Facilitator credentials are optional only as a complete group: none enables challenge-only mode, all three enable settlement, and a partial credential group stops startup. Protected resources are never released in challenge-only mode.

Start the frontend

In a second terminal:

cd frontend
npm install
cp .env.example .env.local
npm run dev

Open http://localhost:3000. The example frontend environment points to the local backend at http://localhost:8000.

Run tests

Backend:

cd backend
pytest

Frontend:

cd frontend
npm run lint
npm run build

SDK commands are documented in the Published SDKs section.

Deployment

Component	Platform	Address
Frontend	Vercel	delta-zero-alpha.vercel.app
Backend	Railway	deltazero-production.up.railway.app
Source control	GitHub	Teecash96/DeltaZero

Production CORS permits the deployed frontend plus local Next.js development origins and exposes the x402 response headers to approved browser origins. The frontend API origin is configured through NEXT_PUBLIC_API_BASE.

Security Model

• DeltaZero never asks for a seed phrase or private key.
• Wallet analysis does not request trading signatures, approvals, or transaction permissions.
• Free-preview mode releases analysis without payment; setting DELTAZERO_ACCESS_MODE=paid restores the fail-closed payment boundary.
• In paid mode, challenge-only operation never releases a protected resource; settlement requires facilitator-verified payment credentials before protected business logic runs.
• Facilitator API credentials and payment configuration belong in deployment environment variables and must never be committed.
• Hyperliquid access uses read-only public information endpoints.
• Aave access uses configured read-only RPC calls.
• Morpho access uses its supported public API.
• External-protocol failures are isolated and returned to the caller.
• Short-lived in-memory caching is used; the current MVP has no database.
• Recommendations are analytical outputs, not trade instructions or execution.

FAQ

Is DeltaZero non-custodial?

Yes. The current product does not hold funds, connect wallets for signing, or execute transactions.

Does DeltaZero execute trades?

No. DeltaZero provides deterministic risk analysis and structured recommendations only.

Which assets does the strategy interface support?

The current Builder, Auditor, and Stress Test interfaces support SOL and ETH.

Which target styles are available?

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

How is a recommendation generated?

The backend evaluates carry, hedge alignment, Safety Buffer, capital risk, service-specific thresholds, and impairment where relevant through deterministic rules.

What is Decision Confidence?

Decision Confidence measures how clearly the evaluated metrics support the recommendation. It does not measure expected profitability or guarantee strategy quality.

Which wallet integrations are live?

Hyperliquid and Morpho are live read-only integrations. Aave is live with configured RPC access. Coverage is limited to the positions and networks supported by the current adapters.

What happens when no wallet positions are found?

The Wallet Auditor returns no_supported_positions when all selected sources succeed but no supported positions are detected. It does not generate a risk recommendation for a nonexistent portfolio.

What happens when a data source fails?

With no retrieved positions, the report is marked insufficient_data. If positions are retrieved from other sources, it is marked partial_data, warnings remain visible, and confidence is reduced.

Is submitted data stored?

No. The current implementation has no database and does not retain submitted strategy or wallet inputs.

Can agents use DeltaZero?

Yes. Agents, dashboards, and automated workflows can consume the structured API directly or use the repository-local SDK packages. DeltaZero does not autonomously execute the resulting recommendation.

How are the SDK packages distributed?

The TypeScript SDK is published to npm and the Python SDK is published to PyPI, both as deltazero-core version 0.1.0.

Roadmap

Planned integrations:

• Pendle — fixed-yield, PT, YT, and maturity-risk analysis.
• Ethena — synthetic-dollar and hedged-yield strategy analysis.
• Continuous Funding Monitoring — persistent alerts and multi-venue funding inputs beyond the current on-demand Hyperliquid snapshot.

Additional planned product capabilities include broader read-only network and protocol coverage, multi-wallet monitoring, continuous risk alerts, funding alerts, Safety Buffer alerts, saved reports, and expanded ASP API access.

Roadmap items are not presented as currently connected or available.

Contributing

Contributions are welcome through GitHub issues and pull requests.

Before submitting a change:

1. Keep calculations deterministic and centralized.
2. Preserve existing route and response contracts unless a versioned change is agreed.
3. Add or update regression tests for decision behavior.
4. Run backend tests, frontend lint, and the production frontend build where relevant.
5. Do not commit secrets, private RPC URLs, build artifacts, or local environment files.

License

DeltaZero is released under the MIT License.

Copyright (c) 2026 Akanbi Labs.

Built by Akanbi Labs

DeltaZero is designed and built by Akanbi Labs for the OKX AI Hackathon.

Follow product updates on X.