More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Algorithmic Execution & Smart Order Routing

    1

    Quantitative crypto execution algorithms for TWAP, VWAP, and slippage-controlled order slicing.

    $14

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Algorithmic Execution & Smart Order Routing

    Algorithmic Execution & Smart Order Routing

    Example session with this skill installed

    Calculate a TWAP execution plan for buying 500,000 RESOLV tokens over 60 minutes. The mid-price is 0.045 USDT, and Depth 1% is $12,000 USDT. Factor in a 20 bps fee.

    • Read your context and instructions
    • Compiled the algorithmic execution

    I have calculated the TWAP execution strategy for your RESOLV order. To minimize slippage, the plan uses 12 five-minute intervals and strictly adheres to liquidity-aware slice sizing.

    TWAP Execution Plan: RESOLV/USDT

    MetricValue
    Total Order Notional22,500.00 USDT
    Target Duration60 Minutes
    Interval Frequency ($\Delta t$)5 Minutes
    Total Slices (N)12
    Max Allowable Slice600.00 USDT (5% of Depth 1%)
    Calculated Slice Size ($q_i$)1,875.00 USDT
    Friction Estimate (bps)35.00 bps

    Strategy Overrides

    Because the calculated slice (1,875 USDT) exceeds the safety threshold of 600 USDT (5% of $12k Depth), I recommend increasing the execution window to 188 minutes or splitting the trade across 38 slices to remain below the 80 bps market impact curve.

    Execution Parameters (Python Decimal)

    from decimal import Decimal
    
    # Precision-safe parameters for RESOLV
    tick_size = Decimal('0.00000100')
    lot_size = Decimal('1.00000000')
    min_notional = Decimal('5.00')
    
    # Slice 01 target
    price = Decimal('0.04500000').quantize(tick_size)
    quantity = Decimal('13333.00000000').quantize(lot_size)
    notional = (price * quantity)
    
    print(f"Price: {price:.8f}")
    print(f"Qty: {quantity:.8f}")
    print(f"Total Notional: {notional:.2f} USDT")
    

    Next steps

    1. Pull the current PRICE_FILTER from the Binance exchangeInfo endpoint to verify tick precision.
    2. Confirm if the execution window can be extended to 190 minutes to reduce market impact.
    3. Verify that the 20 bps fee tier matches your current Binance VIP level.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Large orders in low-liquidity crypto markets suffer from aggressive slippage and front-running. This skill implements quantitative execution strategies to minimize market impact and manage order book depth. It provides logic for slicing institutional-sized trades into manageable tranches across Binance Spot and Futures markets.

    What it does

    • Execution Slicing implements TWAP, VWAP, and Iceberg architectures to distribute order size over time.
    • Liquidity Analysis calculates touch spreads and cumulative depth bands at 1% and 2% intervals from mid-price.
    • Friction Modeling estimates net execution costs including exchange fees, half-spreads, and market impact.
    • Precision Management handles sub-cent tick sizes and decimal quantization for micro-cap assets.
    • Slippage Mitigation enforces notional limits based on real-time order book depth to prevent price spikes.

    How it works

    1. Analyze Depth by summing bid/ask notionals within normalized price bands relative to the mid-price.
    2. Select Strategy between time-weighted, volume-weighted, or hidden iceberg slices based on trade urgency.
    3. Calculate Slices using decimal arithmetic to ensure compliance with exchange LOT_SIZE and PRICE_FILTER rules.
    4. Model Friction to estimate total basis point (bps) drag before committing capital.

    Frameworks & tools

    Python Decimal library, Binance API standards (Spot and Futures), and quantitative finance models for market impact and volume distribution.

    Why this beats prompting it yourself

    Standard LLM prompts often fail at high-precision decimal arithmetic and scientific notation errors like "0E-8" which crash exchange APIs. This skill provides specific mathematical formulas for liquidity-aware sizing that basic prompting ignores.

    Use cases

    • Micro-cap Accumulation of illiquid tokens without spiking the entry price.
    • Institutional Offloading of large positions using VWAP to match historical volume curves.
    • Hidden Liquidity deployment via Iceberg orders to prevent adverse front-running.

    Known limitations

    Requires external price and depth data feeds from Binance APIs to calculate real-time bands. Only supports USDT-denominated notional calculations.

    Requires external price/depth data. Limited to Binance API standards. USDT-only notional calculations.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    Permissions

    No special permissions declared or detected

    Listed28 days ago

    What's inside

    Frequently Asked Questions

    This skill mitigates price slippage and front-running by programmatically slicing large orders into smaller tranches using TWAP, VWAP, and Iceberg logic, ensuring institutional-sized trades don't disrupt low-liquidity markets.

    The skill is designed for Python-based trading agents and is optimized for the Binance API ecosystem, covering both Spot and Futures markets.

    You receive the complete quantitative logic for the execution strategies, including liquidity analysis modules, friction modeling formulas, and decimal precision handlers ready for integration.

    Unlike standard LLMs that struggle with floating-point errors, this skill uses strict decimal arithmetic to meet exchange LOT_SIZE requirements, preventing API rejects caused by scientific notation or rounding issues.

    The skill requires a live data connection to Binance (Spot or Futures) to ingest real-time order book depth and mid-price data for its liquidity calculations.

    Yes, the skill includes friction modeling logic that calculates estimated basis point (bps) drag, factoring in exchange fees and half-spreads before you commit capital to a trade.

    New in Trading & Investing