V1 — Build scope (beta deliverable in 8-10 weeks)

Restructured after CTO/lead eng feedback. Golden rule: before the autonomous agent, we build the best trading scanner in the world. Autonomy is the roadmap (V2/V3), NOT the MVP. Spec detail: technical spec.

The vision, in one sentence

PANDORA is not a trading robot. It is a decision engine that industrializes an already profitable method — turning 7% human coverage into 100% machine coverage, without degrading quality.

The 3 layers (NEVER mix them)

Layer Role Content
V1 · Scanner — the brain find the best setups, at scale data → features → rules (method) → score → top 10 → dashboard → journal
V2 · Companion — the risk manager manage risk & discipline portfolio (caps/heat/drawdown) · calendar (OPEX/earnings/macro) · discipline coach · family rotation · gamma squeeze · LLM that explains
V3 · Agent — autonomy close the loop memory / learning · IBKR · execution · live sizing

The 8-10 week deliverable = V1. Period.

V1 architecture (simple, 100% deterministic)

Market read (morning)   (trinity SPX/SPY/QQQ · GEX/DIX · VIX/term → bias + risk-on/off)
   ↓  (global throttle)
~750 tickers (final universe TBD)
   ↓
Data Layer        (Skylit + UW + TV ; + short interest/CTB/call-delta)
   ↓
Feature Engine    (GEX/VEX per strike · OI/ΔOI · flow · dark pool · IV · OHLC)
   ↓
Rule Engine       (THE method: structure/patterns + gamma squeeze + IV-earnings + rotation)
   ↓
Quality Score     (weighted sum + Explainability = the "why")
   ↓
Top 10 setups     (intraday plan → extendable to swing)
   ↓
Dashboard   +   Journal (proprietary dataset = the moat)

Detailed step-by-step flow: technical spec §0.2 ("what the agent executes"). No LLM in the decision path. No IBKR. No memory. No autonomy.

What V1 produces (every setup is EXPLAINED)

RGTI · family Quantum · Score 92  → GO
Entry 20.50 · Stop 20.29 · Target 27.50 · RR 3.3:1
Why:
  +18  OI build (ΔOI>0 at the target strike)
  +14  Fresh floor (1st tap)
  +12  Reverse rug
  +10  Dark pool aligned with the node
  +8   Risk-on regime
  = 92

Explainability (sum of contributions per feature) is non-negotiable — a score without the "why" is unusable. (This is already the shape of the §5 score.)

CONTRACTUAL definition of V1 (DONE) — what the dev delivers

Input: ~750 tickers (Skylit universe). Output: a sorted JSON, per run:

[
  { "ticker":"META", "family":"Megacap", "setup_type":"structure",
    "score":84, "verdict":"GO", "direction":"long",
    "entry":574, "stop":568, "targets":[590,600], "target_swing":612, "rr":3.1,
    "reasoning":"+18 OI build · +14 fresh floor · +12 reverse rug · +10 dark pool · +8 risk-on" }
]
  • a market read of the day (bias/risk) at the top, and the top 10 highlighted. Constraints (DONE = all true): run < 20 min · 1×/day · ≥ 95% of tickers processed · every setup explained (contributions) · no IBKR · no memory · no companion · no LLM in the decision · idempotent outputs (same inputs → same outputs) · everything logged.

V1 · what to build

# Block Detail Ref
0 Market read (morning) trinity SPX/SPY/QQQ + GEX/DIX + VIX/term → directional bias + risk-on/off; global throttle, shown at the top §0.2, §3
1 Data Layer abstract adapter + Skylit/UW/TV providers; per ticker: GEX/VEX maps, OI/ΔOI, flow, dark pool, IV, OHLC + short interest/CTB/call-delta (for the squeeze) §2, §3
2 Feature Engine map (King/floor/ceiling/pivot/air pocket), real-vs-hedge, fresh/delivered, OTE/discount, RR §4
3 Rule Engine — the method as algorithms ⚠ turn every concept into a boolean: reverse_rug, rug, charts-first (Price>SMA50>SMA200 OR HH+HL OR level breakout), air_pocket, day type, trinity. The real work of V1. §4 + coverage
4 Gamma squeeze (detector) ⭐ core of the method: multi-data gamma_squeeze score (call/put ratio, OI above spot, IV-up-with-price, short interest/CTB, call delta, ITM strikes, short gamma), per asset → boosts the score on longs §6.3
4b IV-expansion earnings ⭐ separate setup category: earnings 7-12d + IV rank↑ + inverted term → capture the IV ramp (not the crush) iv-expansion
5 Families & rotation ⭐ family tag (data/families.csv done) + strength/rotation by family (daily cross-sectional aggregation, gets richer with the panel history) §6.2
6 Quality Score + Explainability weighted sum (includes gamma_squeeze, family_rotation) + contributions per feature; verdict GO/WATCH/PASS §5
7 Dashboard top 10, read per setup, view by family + hot families —
8 Journal every decision + outcome → proprietary dataset §3, §7

⭐ Why squeeze + rotation are in V1: they are the method's setups (Signal Sigma/Talon), 100% deterministic, on data already ingested. Without them the scanner only scans generic King Nodes — not your setups. This is not "companion" work, it is the rule engine.

Out of V1 (explicitly deferred)

LLM that decides ❌ · IBKR execution ❌ · memory/learning ❌ · discipline coach ❌ · portfolio risk ❌ · calendar (OPEX/earnings/macro) ❌ · LLM conviction ❌ · LLM-vision TA ❌ → V2/V3.

Execution phasing & complexity (lead-eng estimate, 1 senior dev + AI)

Phase Duration Content Output
P0 · Infra ~2 wk adapters · scheduler · journal · storage running data pipeline
P1 · Engine ~6 wk features · rules (patterns/squeeze/iv/rotation) · score+explain · ranking top 20 explained setups
P2 · Companion ~4 wk portfolio (sizing/risk/caps) · calendar · explanatory LLM risk manager
P3 · Agent ~4 wk IBKR · execution · (memory only after ≥1000 logged trades) semi-auto

= P0+P1 (~8 wk) = the deliverable V1. P2/P3 = roadmap. Honestly: the real complexity is high per block — pattern detection 9/10 · fresh node 8/10 · data adapters 8/10 · IBKR 9/10 · memory 9/10. So "everything in 6 months with 1 dev" would be a bluff: 3 months engine + 3 months productionizing, and learning is gated (1000 trades). We sell a clean V1, not a miracle.

The 5 V1 success KPIs

KPI Target
Coverage 7% → 100% of tickers
Scan time 60 min → < 5 min
Precision top 10 = > 60% playable setups
Hit rate > human baseline (Léo)
Adoption 80% of executed trades come from the PANDORA top 10

The moat (key nuance)

The moat is NOT "the agent learns" (premature). The moat = the proprietary decision dataset that the journal accumulates from V1 — it will enable learning later (V3). In V1: we log, we do not "learn".

The LLM's role (never in the decision)

Deterministic = perceives → filters → scores → ranks. The LLM (V2) only explains / challenges / summarizes — never on the critical path (otherwise cost, latency, non-reproducibility and hallucinations explode).

V2 · Companion (roadmap)

Portfolio risk brain · discipline coach · calendar (OPEX/earnings/macro) · explanatory LLM · conviction with uncertainty. (Squeeze & rotation are in V1.) → technical spec §6.4.

V3 · Agent (roadmap)

Memory / learning (walk-forward recalibration) · hybrid IBKR execution (paper→live) · live half-Kelly sizing · trade lifecycle · proactive alerting. → §6.1, §6.5, §7.

North Star — PANDORA = Léo's trading 2nd brain (V3+)

The horizon. Eventually PANDORA does not just scan: it remembers all your trading and you can ask it anything. This is not a pivot — it is the natural consequence of the architecture (plain-text + journal + Claude on top). - Queryable memory: your method (academy/docs) + every decision + result (journal) + your TradingView annotations + the regimes/markets seen. You ask: "win rate on reverse-rug in quantum?", "what did I decide the last time META looked like this?", "summarize what changed this week" → it answers from the whole set. - Grows every day: every run + every logged trade enriches it (the compounding moat); after the gate (≥1000 trades) it learns. - You never re-explain yourself: the context (CLAUDE.md / method docs) loads at every session. - Principles our architecture already holds: plain-text (markdown + journal) · you own the brain (Git repo, zero lock-in) · model-agnostic (point another LLM at it) · self-maintenance (cron) · reusable skills. - Security (golden rule): keys, not prompts — "don't delete this" is a suggestion, not security. We control at the permissions level (read-only, scoped keys), never through the prompt. - Phasing: V3+, not V1. But V1 already plants it (everything is plain-text, logged, model-agnostic).

Reusable existing code (do not rebuild)

gex_flip · scanner_poc · gauntlet (anti-overfit) · decision_log · cross-sectional panel collector (built; free TV demo = ~daily collectable snapshot; constraint = reliable collection [cron]; UW later for richer data) · data/families.csv · live dashboard.

The dev settles with Léo, day 1

The Rule Engine algorithms (#3 — reverse_rug & co first), the thresholds (air pocket, fresh/delivered, GO=70), the final family taxonomy, and the definition of "playable" (precision KPI).