2026-05-05 · ATLAS v3 build · Decide & ship

Build the v3 system + interactive dashboard. 5 days end-to-end.

This is the build blueprint. After three rounds of LLM ensemble review and a public-OSS landscape survey (Tauric, NautilusTrader, Hummingbot, Qlib, AlphaAgent, AgentQuant, QuantaAlpha, freqtrade), the architecture is locked: bundle-canonical containerised Python + NautilusTrader determinism contract + event-ledger parity + tiered binary observability + Hummingbot-style cost honesty + Tauric-pattern agent meta-layer.

This blueprint asks the 9 questions I need answered to start. Most are 30-second decisions. Once submitted, parallel agents execute days 1-5 against your YES/MODIFY/NO answers. SELAR (the diagnostic test) runs ~day 3; if it explains ≥80% of the Sharpe gap by module, build continues. If it doesn't, kill criteria trigger and we regroup.

Mode Build blueprint Decisions 9 Execution 5 days, parallel agents Gate SELAR by day 3

TL;DR

What we're building. A working ATLAS v3: deterministic bundle-canonical strategy runner; SMA-4 BTC + ETH + a3_btc_lead_lag as the calibration set; SELAR diagnostic to attribute the Sharpe gap; tiered observability with BLAKE3 chain hash; Hummingbot-style cost model; interactive replay+divergence dashboard.

What I need from you. 9 decisions: 5 hard yes/no on architecture (commit to bundle-canonical, lift OSS, SELAR-as-gate, calibration set, branch strategy); 3 operational (funding-data scope, container substrate, DB allocation); 1 dashboard scope (minimal/standard/full).

Decision gate at day 3. SELAR either attributes ≥80% of the gap by module or it doesn't. If yes — productionise. If no — kill criteria trigger; we regroup before pouring more time in.

Tripwire. Original 2026-06-22 becomes irrelevant under this execution. Realistic: working system with paper trading + dashboard by 2026-05-12. Original tripwire date repurposed for hardening + HSP volume + PLE start.

What's already locked (FYI — these are not decisions, just context)

Architecture: bundle-canonical containerised Python; one deterministic event-driven runner; parity judged on event-ledger alignment with 4 divergence classes (data/timing/logic/cost).

Strategies are bundles, agents are roles. Strategies stay as deterministic Python in containers. Bull/Bear/Risk debate sits ON TOP as meta-layer (Tauric pattern), never as the signal generator.

Build order: A.1' calibration decomposition → A.3' minimal executor + Wrap → A.6' decision-trace + parity-diff harness FIRST-CLASS → A.4' minimal gates → A.5' exact cost model → A.2' JSON wire format derived from what proved necessary.

OSS lifts already decided: NautilusTrader determinism contract, Hummingbot TradeFeeBase, freqtrade Hyperliquid/Bybit connectors, Qlib qrun YAML schema, AgentQuant WarmupEnforcer, AlphaAgent dedup penalty, QuantaAlpha trajectory, Tauric memory.py + checkpointer + structured-output-regex pattern + bull/bear sub-graph shape.

Tripwire success criterion: SELAR explains ≥80% of the Sharpe gap (0.31 vs 3.19 on SMA-4) by module: data / timing / warmup / cost / logic. Not "system finished" — "root-cause engine works."

Execution timeline (what runs when, given YES on the decisions below)

Day 1

Foundation — 4 parallel agents + me coordinating

Agent A bundle manifest schema + WarmupEnforcer + SMA-4 BTC reference bundle

Agent B container build + freeze + first deterministic replay

Agent C Hummingbot cost model lift + Bybit/Hyperliquid venue config + Argus funding wire-up

Agent D event-ledger schema + writer + Tier 0/1 observability + BLAKE3 canonical encoder

Me determinism-contract policy doc + integration + Tauric pattern lifts

Output: SMA-4 BTC frozen as a reproducible bundle, replays deterministically twice (same hash), cost ledger emits per-trade events

Day 2

Parity layer — 4 parallel agents

Agent A comparator (4 divergence classes: data / timing / logic / cost)

Agent B SELAR Run 0 (upstream native env) and Run 1 (ATLAS container, upstream data)

Agent C SMA-4 ETH + a3_btc_lead_lag freeze (parallel calibration set expansion)

Agent D dashboard MVP — replay UI on event ledger (FastAPI + Streamlit + Lightweight Charts)

Output: Run 0 ledger captured, Run 1 produced + diffed, comparator emits first divergence-class report. Dashboard live at port 8098.

Day 3

★ DECISION GATE — SELAR diagnosis ★

Agent A SELAR Run 2 (canonical data swap)

Agent B SELAR Run 3 (timing/warmup swap)

Agent C SELAR Run 4 (cost model swap)

Agent D SELAR Run 5 (ATLAS port — last)

Me attribution report: where did the Sharpe gap come from

If ≥80% of gap attributed by module → continue to days 4-5
If <80% attributed or unattributable → kill criteria triggered; stop, regroup, redesign

Day 4

Productionise — only fires if gate passes

Agent A wire one calibration strategy into ATLAS paper trading with deterministic replay matching live ledger

Agent B divergence visualisation in dashboard + SELAR attribution chart + parity-report rendering

Agent C HSP MVP shell (human-curated seed → typed Python project → bundle freeze → SELAR)

Agent D Tauric pattern lifts (memory log + structured output → regex parse + checkpointer + two-tier LLM split)

Output: live paper trade running through v3 stack; dashboard shows the trade in real time

Day 5

Harden + document

Agent A Tier 2/3 observability (sampled fingerprints + divergence-triggered traces)

Agent B dashboard polish: bundle manager UI, regime classifier panel, Lightweight Charts overlay

Agent C Providence artefact draft (methodology doc with SELAR result + parity-discipline numbers)

Agent D stress overlays (operator's 25/50/75/100bps decay sweep + funding adverse) on top of primary cost model

Output: working v3 + interactive dashboard + published methodology, all backed by SELAR-validated parity

Decisions (9 total, ~3 minutes to answer)

Yes

Modify

Pending