QuantumExecute (QE) Unified Skill

QuantumExecute is abbreviated as QE. This is a single install skill for QuantumExecute cryptocurrency execution workflows across Binance, OKX, LTP, Deribit, Hyperliquid, and other supported exchanges.

QuantumExecute provides AI-driven execution algorithms for quantitative institutions and large-order trading. It focuses on reducing execution cost through smart order splitting, plug-and-play exchange connectivity, customizable strategies, order lifecycle management, balance/position visibility, and TCA/reporting.

Use script outputs as the only source of truth.

Features

• Multi-exchange crypto execution workflows for Binance, OKX, LTP, Deribit, Hyperliquid, and other supported exchanges.
• AI-driven execution support for quantitative institutions and large-order trading.
• Smart order splitting and algorithmic execution workflows for TWAP/VWAP/POV-style orders.
• Plug-and-play account discovery, market data checks, order lifecycle management, and fill queries.
• Balance, margin, and position visibility across spot, margin, perpetual, futures, and options where supported by scripts.
• TCA analysis, Excel exports, and execution-cost review workflows.
• Strategy customization through script parameters and exchange-account specific routing rules.

Official Links

• Website: https://www.quantumexecute.com/
• API Docs: https://api.quantumexecute.com/trading-api
• Golang SDK: https://github.com/Quantum-Execute/qe-connector-go
• Python SDK: https://github.com/Quantum-Execute/qe-connector-python

New User Onboarding

1. Register an account on the QuantumExecute website.
2. In QuantumExecute trading account management, bind your exchange API key.
3. Add QE page IP addresses to your exchange API whitelist.
4. Create a QuantumExecute platform API key.
5. Use QE_API_KEY and QE_API_SECRET for authenticated scripts.

API Key Setup

Create a local env file:

cat > ~/.qe.env << 'EOF'
export QE_API_KEY="your_qe_api_key"
export QE_API_SECRET="your_qe_api_secret"
EOF
chmod 600 ~/.qe.env

Load credentials before running authenticated scripts:

source ~/.qe.env

Validate without printing secret values:

[[ -n "$QE_API_KEY" ]] && echo "QE_API_KEY loaded" || echo "QE_API_KEY missing"
[[ -n "$QE_API_SECRET" ]] && echo "QE_API_SECRET loaded" || echo "QE_API_SECRET missing"

Usage Examples

# Discover bound exchange accounts
List my QuantumExecute exchange API bindings.

# Check market data before trading
Get the latest BTCUSDT market quote.

# Query balances and positions
Check my Binance account spot balance, margin balance, and futures positions.
Check my OKX account spot balance and derivatives positions.
Check my LTP account spot assets, margin debt, and derivatives positions.
Check my Deribit account balances and futures/options positions.
Check my Hyperliquid spot balance and perp positions.

# Order lifecycle
Create a Binance DOGEUSDT TWAP order after running the required pre-checks.
Show details and fills for master order <masterOrderId>.
Cancel master order <masterOrderId>.

# TCA and reporting
Generate TCA analysis for master order <masterOrderId>.
Export order fills to Excel.
Generate TCA analysis for recent completed orders.

Configuration Requirements

• Python 3.9+.
• Python dependencies from requirements.txt:
  • qe-connector
  • requests
  • pandas
  • openpyxl
• QuantumExecute platform credentials:
  • QE_API_KEY
  • QE_API_SECRET
• Optional local output folder:
  • QE_WORKSPACE for generated reports.
• New users must register at QuantumExecute, bind exchange API keys, whitelist the IPs shown in the QuantumExecute UI, then create a QuantumExecute platform API key.

Capability and Credential Declaration

• This is a crypto execution/trading integration with authenticated read and write access through QuantumExecute APIs.
• Authenticated scripts can read exchange bindings, balances, positions, orders, fills, and TCA data.
• Order scripts can create, update, and cancel orders on exchange accounts bound to the QuantumExecute account.
• QE_API_KEY and QE_API_SECRET are required high-privilege credentials. Use restricted QuantumExecute keys, exchange API IP whitelisting, minimal exchange permissions, and audit logs where available.
• QE_BASE_URL is optional and should only point to trusted QuantumExecute endpoints. QE_WORKSPACE is optional and controls local report output.

Capability Routing

• Trading/order lifecycle: references/trading.md
• Balance/position/margin visibility: references/balance.md
• TCA and exports: references/tools.md
• Safety controls: references/safety.md
• Error handling and anti-fabrication: references/errors.md
• Fixed response templates: references/output-formats.md

Hard Rules (P0)

1. Execute scripts first; no fabricated values.
2. For create/update/cancel operations, require explicit user confirmation.
3. Keep numeric precision and pagination fields (total/page/pageSize) from script outputs.
4. Report stderr/error when scripts fail; do not hide failures.
5. Keep credentials in env vars only (QE_API_KEY, QE_API_SECRET).
6. Apply trading risk checks and parameter validation from references/trading.md before order writes.
7. Use fixed response templates from references/output-formats.md for order completion and TCA summaries.

Notes

• Always run account discovery with list_exchange_apis.py before choosing an account-specific script.
• Always run market-data and account pre-checks before create/update/cancel order operations.
• Treat notify_order_complete.py as optional and OpenClaw-oriented; generic hosted agents should prefer direct status queries.
• Do not expose full exchange API keys, QuantumExecute credentials, or local env files.
• Generated reports should be written to QE_WORKSPACE or the default local workspace.

Run

python3 scripts/<script>.py --help