# Paradex Strategy Builder

> >

- **Type:** Skill
- **Install:** `agentstack add skill-tradeparadex-paradex-skills-strategy-builder`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [tradeparadex](https://agentstack.voostack.com/s/tradeparadex)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [tradeparadex](https://github.com/tradeparadex)
- **Source:** https://github.com/tradeparadex/paradex-skills/tree/main/skills/strategy-builder

## Install

```sh
agentstack add skill-tradeparadex-paradex-skills-strategy-builder
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Paradex Strategy Builder

Translates trading ideas into structured, testable strategy specifications.
Uses Paradex MCP tools for historical data analysis and validation.

## Important Boundary

This skill produces **strategy designs and historical analysis** — it does NOT
execute trades. If the user wants to execute, point them to the Paradex MCP
order management tools (available when authenticated) or the paradex-py SDK.

## Available MCP Tools for Strategy Development

| Tool | Strategy use |
|---|---|
| `paradex_klines` | Historical price data for backtesting signals |
| `paradex_trades` | Trade flow analysis for entry timing |
| `paradex_orderbook` | Liquidity analysis for execution planning |
| `paradex_funding_data` | Funding rate history for carry strategies |
| `paradex_market_summaries` | Cross-market screening for opportunity detection |
| `paradex_markets` | Tick sizes, position limits, min order sizes for realistic sizing |
| `paradex_bbo` | Current spread for execution cost estimation |

## Strategy Design Process

### Step 1: Capture the Idea

Extract from the user's description:
- **Market(s)**: Which Paradex market(s)? Or cross-market?
- **Thesis**: What market behavior does this exploit?
- **Direction**: Long-only, short-only, or both?
- **Timeframe**: Scalping (minutes), intraday (hours), swing (days), carry (weeks)?
- **Edge source**: Technical (price patterns), structural (funding), statistical (mean reversion)?

If the user's description is vague, ask clarifying questions.
If they want a template, offer one from the catalog below.

### Step 2: Define Rules

Structure every strategy as:

```
STRATEGY: [Name]
MARKET: [market_id]
TIMEFRAME: [resolution for signals]

ENTRY RULES:
- Condition 1: [specific, measurable]
- Condition 2: [specific, measurable]
- Entry type: [market/limit] at [price logic]
- Position size: [sizing rule]

EXIT RULES:
- Take profit: [condition or price level]
- Stop loss: [condition or price level]
- Time stop: [max holding period if applicable]
- Trailing stop: [if applicable]

RISK PARAMETERS:
- Max position size: [in base currency and USD]
- Max loss per trade: [dollar or percentage]
- Max concurrent positions: [number]
- Max daily loss: [dollar or percentage, then halt]

FILTERS:
- Only trade when: [market regime, volume, spread conditions]
- Avoid when: [conditions that invalidate the edge]
```

### Step 3: Historical Validation

Use MCP data to check if the strategy would have worked:

1. **Fetch historical data**: `paradex_klines` for the relevant period and resolution
2. **Compute signals**: apply the entry/exit rules to historical data
3. **Count opportunities**: how many entry signals in the lookback period?
4. **State the current regime explicitly** using `paradex_klines` before estimating outcomes.
   For mean reversion: confirm the market is Ranging (ADX  70
4. Target: middle band (20-period SMA)
5. Stop: 1.5 ATR beyond entry

**Key data:**
- `paradex_klines`: compute bands, RSI, ATR
- `paradex_orderbook`: check liquidity at entry/exit levels

**Risk factors:**
- Trending markets destroy mean reversion — use regime filter
- Requires tight stops which get hit frequently in volatile markets

### Template 3: Momentum / Trend Following

**Thesis**: Strong moves tend to continue.

**Implementation:**
1. Detect breakout: price closes above 20-period high with volume > 1.5x average
2. Enter on breakout confirmation (2 consecutive closes above level)
3. Trail stop: 2 ATR below highest close since entry
4. No fixed take-profit — let winners run, trail protects

**Key data:**
- `paradex_klines`: price highs, volume
- `paradex_trades`: confirm volume spike is real trades, not wash

**Risk factors:**
- Many false breakouts in ranging markets
- Requires patience — low win rate, large winners

### Template 4: Grid Trading

**Thesis**: Profit from price oscillation within a range.

**Implementation:**
1. Define range: support at $X, resistance at $Y (from kline analysis)
2. Place buy orders at N evenly spaced levels from support to midpoint
3. Place sell orders at N evenly spaced levels from midpoint to resistance
4. Each buy has a corresponding sell (take-profit) a grid step higher
5. Each sell has a corresponding buy (take-profit) a grid step lower

**Key data:**
- `paradex_klines`: identify the range bounds
- `paradex_markets`: min_notional and tick_size for grid spacing
- `paradex_orderbook`: ensure grid levels have liquidity

**Risk factors:**
- Range breakouts cause significant losses on one side
- Capital-intensive — funds spread across many open orders
- Best for ranging, low-volatility periods

### Template 5: Basis Trading (Spot vs. Perp)

**Thesis**: Exploit price differences between spot and perpetual markets.

**Implementation:**
1. Monitor basis: perp_price - underlying_price (from market_summaries)
2. When basis is high (perp premium): short perp, long spot equivalent
3. When basis is low (perp discount): long perp, short spot equivalent
4. Collect funding while basis normalizes

**Key data:**
- `paradex_market_summaries`: mark_price vs underlying_price
- `paradex_funding_data`: funding rate trend
- Requires spot market access (Paradex supports spot trading)

**Risk factors:**
- Basis can widen before converging
- Execution risk: need to enter both legs simultaneously

### Template 6: Short Premium (Covered Strangle / Short Strangle)

**Thesis**: Collect option premium by selling OTM calls and puts, profiting from
time decay when the underlying stays within the expected range.

**Implementation:**
1. Use `paradex-options-pricer` to scan sell candidates — target 15–35 DTE,
   25–30 delta options with high IV relative to the chain
2. Sell the OTM call at the selected strike and the OTM put at the equivalent delta
3. Delta-neutralise the combined position using `paradex-pm-analyzer`
   (pm-analyzer computes the net portfolio delta and sizes the perp hedge)
4. Monitor daily: re-run pm-analyzer and re-hedge if portfolio delta drifts beyond ±0.05

**Key data:**
- `paradex_markets` + `paradex_market_summaries`: option chain, IV levels
- `paradex-options-pricer`: sell candidate ranking and spread width check
- `paradex-pm-analyzer`: IMR/MMR impact and delta-hedge sizing
- `paradex_klines`: historical range analysis to set strikes above/below key levels

**Risk factors:**
- Unlimited loss on the short call if the underlying makes a large upward move
- Short put has substantial downside if the underlying drops sharply
- IV expansion (vega risk) increases the mark value of the short position — rising IV hurts sellers
- Significant margin requirements — always check IMR/MMR with pm-analyzer before entry

**When to use / avoid:**
- Use: ranging market, ATM IV elevated vs. recent realized vol, DTE 15–35
- Avoid: strongly trending market, upcoming binary events (macro announcements, expirations)
- Kill: buy back if unrealized loss exceeds 2× premium collected, or if IV spikes >50% above entry IV

## Output Format

### Strategy Specification
```
## Strategy: [Name]
### Thesis
[1-2 sentences: what market behavior does this exploit?]

### Rules
[Structured entry/exit/risk rules as above]

### Historical Check
[Results from validation using MCP data]

### Execution Notes
[Practical considerations: fees, sizing, spread costs]

### Risk Summary
- Max expected loss per trade: $X
- Win rate estimate: X%
- Key risk: [biggest thing that can go wrong]
- Kill condition: [when to abandon the strategy entirely]
```

## Visual Preview

After producing a strategy JSON the user can render a one-page preview (header,
legs, entry/exit rules, theoretical payoff at expiry) using
`tools/strategy-viz/cli/render_strategy_card.py  ` — no
backtest required. The same card can be emitted as a `webchat-ui-renderer`
spec via `tools/strategy-viz/cli/to_webchat.py`. Layout conventions follow
pyfolio / quantstats tear sheets and options-platform "command center"
dashboards; see `tools/strategy-viz/README.md`.

---

## Caveats

- Historical validation from kline data is NOT a proper backtest — it doesn't account
  for execution quality, fills, queue priority, or concurrent position effects
- All P&L estimates are gross approximations — actual results depend on execution
- Strategy edge can decay — what worked historically may not work going forward
- Paradex retail traders get zero fees, but pro/API traders pay maker/taker fees
  that can significantly impact high-frequency strategies
- This skill designs strategies, not financial advice. Users trade at their own risk.
- For actual execution, the user needs to use the authenticated MCP order tools or
  build a bot using the paradex-py SDK

See [templates.md](references/templates.md) for expanded strategy templates with parameter ranges and example calculations.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [tradeparadex](https://github.com/tradeparadex)
- **Source:** [tradeparadex/paradex-skills](https://github.com/tradeparadex/paradex-skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-tradeparadex-paradex-skills-strategy-builder
- Seller: https://agentstack.voostack.com/s/tradeparadex
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.