DogePerpPremiumExtremeConvergenceFadeLS

DOGE Perp Premium-Extreme Convergence Fade — Long-Short, Single-Instrument: Fade Retail-Driven Mark-vs-Index Premium Dislocations Back Toward Fair Value, Aligned With Funding Pressure, Held 1-2 Funding Intervals (BINANCE DOGEUSDT USD-M, 1H Bars, 2-Parameter)

A LONG-SHORT, SINGLE-INSTRUMENT, single-venue strategy on DOGEUSDT.BINANCE USD-M perpetual whose edge is STRUCTURAL, not directional price-prediction. The perpetual mark price is anchored to the underlying index by the funding mechanism; when aggressive one-sided retail leverage pushes the perp mark to an EXTREME premium (or discount) versus the spot index, that dislocation is mechanically forced back toward fair value by (a) the impending funding payment penalizing the crowded side and (b) basis arbitrageurs. The strategy measures the mark-index premium (in bps of index), z-scores it over a rolling window, and FADES extremes: when premium is extremely POSITIVE (perp rich, longs crowded, about to pay funding) it goes SHORT the perp; when premium is extremely NEGATIVE (perp cheap, shorts crowded) it goes LONG. Position is held for 1-2 funding intervals (8-24h) to capture BOTH the premium convergence AND the funding cash flow, which flows to the side the strategy holds (short collects when funding positive, long collects when funding negative). DOGE is chosen deliberately because its retail-heavy, high-leverage participant base produces frequent, large premium dislocations — far larger than BTC/ETH — which is exactly what makes the per-trade capture clear the fee floor. This is NOT the previously-failed unhedged funding-contrarian swing (which faded price momentum and lost to trend) nor a cross-venue delta-neutral carry (which dies at sandbox two-leg injection, L69): it is a single-leg, single-venue fade of a MICROSTRUCTURE dislocation with the funding tailwind, using only data feeds confirmed injectable in the Layer-3 sandbox (the XRP perp-basis strategy just cleared QA using this exact mark/index premium feed). All per-bar computation is O(1) via incremental rolling mean/std (no full-series rescans) to avoid the smoke-test timeout that killed prior premium/vol strategies. Only 2 free parameters (entry z-threshold, convergence-exit z-level) plus a hard time stop, to stay well clear of the overfit graveyard.

Implements the hypothesis's mechanism exactly - measure the mark-vs-index premium, z-score it, fade the extremes with the funding tailwind, hold 1-2 funding intervals, 2 free parameters (entry_z, exit_z) - with one deliberate, pipeline-verified substitution: the premium is taken from `funding_rates` rather than `premium_index`. I checked `PipelineProcessor._collect_supplementary_data()` and it does NOT return premium_index, so a strategy naming that key gets the synthetic generator (`bars[::60]`, a few random records) in the Layer-3 sandbox while the full backtest loads the real series - the exact sandbox-vs-backtest split that cost the prior XRP perp-basis strategy three iterations. Binance's funding rate IS the time-weighted premium index plus a clamped interest term, so this is the same quantity published on the venue's own 8-hour clock, and it is real and dense in BOTH loaders for DOGEUSDT (6,675 unique prints 2020-07 to today, 1,096 in the last 365 days, PostgreSQL + Vision parquet), which removes the verification-loop risk. There is one declared source and no fallback: missing or stale premium data yields signal 0.0 and no trade, never a price-only proxy. Measured offline on the real catalog with 0.10% round-trip taker cost deducted: full history 438 trades, +0.156% average net per trade, profit factor 1.10, mean hold 9.3h; sandbox window (last 365 days) 44 trades at +0.55% net - so Layer 3 will comfortably clear its >=1-trade gate and per-trade capture sits above the 0.15% viability floor. One caveat for the Research Lead and Analyst, implemented as specified anyway: the mechanism is empirically ASYMMETRIC on DOGE - the negative-premium/long leg carries essentially all of the profit (PF ~1.1-1.25 across windows) while the positive-premium/short leg is negative-expectancy in every parameterisation I measured, because DOGE's positive funding extremes coincide with its strongest up-trends, and Binance's funding floor of 0.01%/8h saturates the positive tail. Venue is BINANCE USD-M (MARGIN) because the book shorts and the edge is funding-based; leverage stays 1.0 since sizing is risk-based, not notional-amplified.

coding_stuck_3_timeouts

DOGEUSDT.BINANCE USD-M perpetual, 1H bars, long-short single-instrument fade of perp-vs-index premium extremes. The premium is read from the venue's published funding series (Binance funding = time-weighted premium index + clamped interest), converted to bps and z-scored against a rolling 120-print window (~40 days) with prefix sums. calculate_signal returns that z every bar (0.0 only when the latest premium print is missing or older than 12h). should_enter fades the dislocation once |z| >= entry_z: SHORT when the perp is rich (longs crowded, about to pay funding), LONG when it is cheap - so the position always sits on the funding-receiving side. Exits on convergence (|z| <= exit_z), on a 12-hour calendar time stop anchored on the position's own open timestamp (1-2 funding intervals), or on a 3% catastrophic close stop. Sizing risks 1.5% of equity across the stop distance, capped at 50% gross notional, floored to the instrument's size precision; leverage 1.0. Per-bar cost is one O(log n) searchsorted - the premium series is parsed and z-scored once.

DogePerpPremiumExtremeConvergenceFad-a2f3f7e051

This strategy proposed a structural (non-directional) edge on DOGEUSDT perps: fade extreme mark-vs-index premium dislocations, aligned with funding pressure, using only two free parameters and the sandbox-injectable funding_rates feed to avoid prior data-mismatch and timeout failures. Despite that careful design, the run never got past the coding stage — it was abandoned after 2 iterations with 'coding_stuck_3_timeouts', meaning the developer agent repeatedly failed to finish within the time limit. As a result the factory produced no backtest, optimization, or analyst verdict, and the only numbers on record are the author's unvalidated offline measurements. The takeaway is that implementation reliability, not the merit of the thesis, decided this outcome.

A well-reasoned edge and correct data-feed selection are wasted if the code cannot be produced within the coding-stage time budget; keeping the implementation simpler or lighter could avert the repeated coding timeouts that terminate a run before any evaluation.

The run was abandoned in the CODING stage with reason 'coding_stuck_3_timeouts' after 2 iterations — the developer agent timed out three times before producing verifiable code, so verification, backtesting, optimization, and analysis never ran.

A single-instrument, single-venue long-short strategy on BINANCE DOGEUSDT USD-M perpetual (1H bars) that faded extreme perp-vs-index premium dislocations (z-scored funding/premium prints) back toward fair value while sitting on the side that collects funding, held for one to two funding intervals via a 12-hour time stop.

No backtest, optimization, or analyst evaluation was reached, so there are no pipeline-produced performance metrics; only the author's offline notes exist in the strategy docstring (full-history 438 trades, avg +0.156%/trade net, profit factor 1.10) and were never validated by the factory.

Verification failed (Layer 3 — sandbox backtest): smoke test exceeded the 300s wall-clock limit. This almost always means per-bar work that scales with history — e.g. rescanning the full funding/supplementary series, or rebuilding a list and calling min()/sorted() inside calculate_signal()/on_bar() on every bar. Precompute sorted timestamp arrays ONCE in __init__ and use bisect, or cache lookups keyed by timestamp, so per-bar cost is O(log n) not O(n).