statisTicker
BUILD: v0.2 PROTOTYPE DATA: SYNTHETIC FIXTURE
DEMO MODE
TAB 01 // PRE-TRADE COMPLIANCE GATE

Order Boundary Enforcement via Multi-Model Arbitration

A synthetic order stream is evaluated against the rules parsed from the client IPS in Tab 02. Five independent evaluators — four open-weight LLMs targeting distinct rule classes plus a non-LLM statistical anomaly layer — vote on each transaction. The CCO controls the consensus threshold ($\tau$). Block decisions derive from the parsed JSON, not hardcoded labels.

Arbitration Consensus Threshold ($\tau$)
Ultra-Conservative (5-of-5)
All five evaluators must independently flag the order. Maximum precision; expect false negatives. Use when audit-grade certainty is mandatory before blocking.
Balanced (3-of-5)
Three independent angles must agree on a breach. Institutional default once thresholds are tuned in production. Tight FP rate, surfaces multi-class violations.
High Recall (Any-of-5)
A single evaluator flag triggers a block. Demo default — surfaces every signal across hard rules and statistical anomaly. Tighten in production once tuned.
Hard Deterministic
Hard IPS rule hits only — ticker, sector, strategy, leverage, concentration. KDE statistical layer is not run. Use as a sanity-check baseline.
Orders Evaluated
0
From synthetic stream
Hard Blocks Issued
0
Breaches of client IPS
Capital Retained
$0
decomposed; see matrix ↓
Mean Eval Latency
0.00 MS
Pre-trade window budget
Order Stream — Synthetic Fixture
Streaming against parsed rules from Tab 02
ID ACCOUNT / DESK ORDER DETAILS LATENCY RESOLUTION
Ensemble Engine Arbitration Telemetry
Select a live execution block from the stream log to decode consensus reasoning and model layer weights.
Confusion Matrix & Decomposed Capital Retention
Value per intercept: $$V_{\text{retained}} = P(\text{inq}|b)\,E[F] + H_{\text{rem}}\,W_{\text{ops}} + s_{\text{bps}}\,N\,P(\text{impact})$$
Mandate Compliant
Mandate Violation
Engine Pass
0
True Negative (Cleared)
0
False Negative (Leakage)
Engine Action
0
False Positive (False Alarm)
0
True Positive (Intercept)
Regulatory Expectation
$P(\text{inq}|b) \times E[F]$
0.12 × $850K
$0
Remediation Labor
$H_{\text{rem}} \times W_{\text{ops}}$
2.4 hrs × $285/hr
$0
Adverse Market Drift
$s_{\text{bps}} \times N \times P(\text{impact})$
18bps × ∑notional × 0.6
$0
TAB 02 // INVESTMENT TEAM WORKFLOW

Dynamic Rule Ingestion & Policy Generation

Paste or edit a Client Investment Policy Statement. The parser extracts structured execution boundaries that the arbitration engine in Tab 01 enforces against every order. The output JSON is the same object the gate evaluates — there is no separate hardcoded rule list.

Load Sample IPS
Parser Mode
Raw Input: Investment Policy Statement
PARSE OK 0 rules · 0 ms
Parsed Execution Boundaries (JSON)

        

          This object is consumed by the Tab 01 evaluator on every transaction.
        

      

    


    

      
Active Rule Summary — what the gate is enforcing right now

      

    

  


  
  
  
  

    

      
TAB 03 // SYSTEM TOPOLOGY

      
On-Premises Parallel Arbitration Flow

      

        Target architecture: raw order flow is mirrored off the OMS into an isolated on-prem GPU cluster, where four
        open-weight LLMs and a non-LLM statistical layer evaluate every proposed trade against the parsed IPS rules. No
        order or PII ever crosses a commercial API boundary.
      

    


    

      
Pipeline Processing Nodes — Pre-Trade Verification

      

        

          
Node 01 // Input

          
IPS Rule Extraction

          
Investment team pastes the client IPS into the workflow surface (Tab 02). The
            parser produces a structured rule JSON. Production target: OpenAI API call with strict output schema; staged
            fallback to the deterministic parser.

          
Isolation: client-side parser today · serverless route planned

        

        

          
Node 02 // Mirror

          
Order-Flow Mirror Tap

          
A read-only FIX session or OMS sidecar mirrors proposed orders before they leave the
            desk. Evaluation runs in parallel with the desk’s native risk check; no critical-path latency added.
          

          
Integration target: Charles River / Aladdin / OMS-native

        

        

          
Node 03 // Core

          
Multi-Model Arbitration

          
Five evaluators run independently on the same order: Gemma 3 4B (ticker/sector),
            DeepSeek V3 (leverage), Qwen 2.5 Math 7B (concentration math), Llama 3.1 8B (strategy class), KDE
            statistical layer (anomaly). Their votes are combined under the CCO’s $\tau$ threshold.

          
Hardware target: on-prem 4×A100 / dual H100 box

        

        

          
Node 04 // Output

          
Verdict + Audit Surface

          
Block / flag / clear verdict back to the OMS within the order’s pre-trade window.
            Every vote and rationale is written to a tamper-evident audit log for the CCO and regulator.

          
Surface: dashboard + signed JSON-LD audit export

        

      

    


    

      
Build Status — what’s real, what’s stubbed, what’s planned
      

      

        We are explicit about state because it matters to a CCO and to us. Demo today is the deterministic-parser
        end-to-end loop; production-grade pieces are scoped below.
      

      

        

          
● Working today (v0.2)

          
    
            
  • Deterministic IPS parser (Tab 02): regex/keyword extraction over real IPS phrasing.
    • 
            
  • Live binding from parsed JSON to the Tab 01 evaluator — what you paste decides what gets blocked.
            
    • 
            
  • Five-evaluator vote stack with distinct rule classes (ticker, leverage, concentration, strategy,
              anomaly).
    • 
            
  • Posture threshold (5-of-5 / 3-of-5 / any-of-5 / hard-deterministic) actually changes the matrix.
    • 
            
  • Confusion matrix and decomposed value formula updated against the synthetic stream.
    • 
          

        

        

          
○ Stubbed for demo

          
    
            
  • The four LLM "votes" are deterministic rule checks against the parsed JSON today — not actual
              on-prem model inference.
    • 
            
  • Transaction stream is a synthetic fixture, not a live OMS mirror.
    • 
            
  • KDE / statistical layer uses a hand-set z-score per fixture row; no real density model yet.
    • 
            
  • OpenAI API mode requires OPENAI_API_KEY set on Vercel; if missing, the front-end falls back
              to the deterministic parser and labels the state.
    • 
          

        

        

          
◇ Planned (next 30 days)

          
    
            
  • Selective-posture-by-rule-class: hard rules (banned tickers / sectors / strategies / leverage) bypass
              posture; the $\tau$ threshold governs only soft signals (statistical anomaly, drift). Today everything is
              uniformly posture-gated — demo shows the tradeoff explicitly.
    • 
            
  • OpenAI-backed parser wired today via /api/parse-ips; next is multi-shot extraction +
              per-rule citation back to the IPS span.
    • 
            
  • On-prem GPU cluster running the four LLMs via vLLM; quantized 4-bit checkpoints.
    • 
            
  • Real KDE fit on rolling per-desk feature windows (volume, realized vol, structure).
    • 
            
  • FIX-tap reference adapter + JSON-LD audit log export.
    • 
            
  • Pilot synthetic-feed harness for warm-logo evaluation (JD lane).
    • 
          

        

      

    

  


  
  
  
  

    

      
TAB 04 // TEAM & ROADMAP

      
Founders, Lanes, and the 30-Day Plan

      

        Demo readiness, lane lock-in, and the path to a first warm-logo pilot. Premature corporate formalities are
        deferred — we are optimizing for a defensible artifact and three named lanes by end of the Sunday call.
      

    


    

      
▶ Sunday Decision Items — lock these before we hang up

      
    
        
  1. Lane lock: each founder leaves the call owning a defined 7-day deliverable (see cards below). No
          “shared” tasks.
    2. 
        
  2. Pilot target: agree on the top two warm-logo candidates for JD to approach this week —
          criterion is: can we get 60 minutes with a CCO or COO before June 7?
    3. 
        
  3. Math & legal sign-off: Persia validates that the three sample IPS templates (Family Office /
          ERISA / Endowment) reflect realistic regulatory language — flag anything that would embarrass us in
          front of a real CCO.
    4. 
      

    


    

      

        
Mash Zahid

        
Technical Lead · Architecture & Build

        
Owns

        
    
          
  • Engine architecture: parser, evaluator, arbitration math.
    • 
          
  • statisticker.net frontend & deploy pipeline.
    • 
          
  • On-prem cluster reference build (vLLM + 4-bit quantized).
    • 
        

        
Next 7 days — June 1 checkpoint

        
    
          
  • Ship `/api/parse-ips` (Vercel serverless, OpenAI-backed) with deterministic fallback.
    • 
          
  • Add real KDE / IQR scoring on a synthetic feature stream.
    • 
          
  • Audit-log JSON-LD export for one demo block decision.
    • 
        

      


      

        
Persia Shokoohi

        
Domain Lead · Compliance & Regulatory Logic

        
Owns

        
    
          
  • Regulatory failure-mode taxonomy (SEC 15c3-5, FINRA 4111, ERISA 404/406, OFAC).
    • 
          
  • Synthetic IPS corpus — 8–10 realistic statements across mandate types.
    • 
          
  • Vendor diligence answer set (FFIEC controls, audit log, regulator-facing reports).
    • 
        

        
Next 7 days — June 1 checkpoint

        
    
          
  • Validate or rewrite the three demo templates against real-world IPS language.
    • 
          
  • Draft 5 additional templates (insurance GA, sovereign wealth, broker-dealer prop, RIA, hedge fund LP).
          
    • 
          
  • One-page failure-mode brief mapping each parsed rule class to its statute / FINRA rule.
    • 
        

      


      

        
JD Henao

        
Pilot & Validation Lead · Warm-Logo GTM

        
Owns

        
    
          
  • Initial pilot-logo pipeline (Booth alumni, NY / Chicago trading desks).
    • 
          
  • 60-minute CCO / COO walk-through structure & objection map.
    • 
          
  • Discovery feedback loop — what changes the demo, what changes the product.
    • 
        

        
Next 7 days — June 1 checkpoint

        
    
          
  • Two warm-logo CCO meetings booked, target before June 7.
    • 
          
  • Common-objection script: latency, on-prem cost, audit defensibility, false-positive economics.
    • 
          
  • Lightweight CRM tracker (pipeline + status + next action) shared with Mash & Persia.
    • 
        

      

    


    

      

        
I. Scientific Stack — the one-screen version

        
Standard enterprise compliance applies binary rules to probabilistic markets — that’s why legacy
          stacks both over-block and leak. Systems thinking circumvents single-agent fragility.


        
Multi-Model Open-Weight Ensemble

        
Four open-weight LLMs (Gemma 3 4B, DeepSeek V3, Qwen 2.5 Math 7B, Llama 3.1 8B Instruct) plus a non-LLM
          statistical anomaly layer. Each evaluates from a distinct angle: ticker/sector, leverage, concentration,
          strategy, statistical outlier. On-prem only — no order flow crosses a commercial API boundary.


        
Arbitration with a Tunable Threshold

        
Models vote independently; the CCO controls $\tau$. Balanced (3-of-5) is the institutional default.
          Ultra-Conservative (5-of-5) minimizes false alarms on high-volume desks. High Recall
          (any-of-5) is a break-glass for known-fragile regimes. Threshold is a policy lever, not a baked heuristic.
        


        
Statistical Anomaly Layer (KDE / IQR)

        
Kernel-density estimation over rolling per-desk features — volume, realized vol, structure (skew,
          margin ratio, basket composition). Tail-region observations are flagged as drift candidates even when no hard
          rule is broken.

      


      

        
II. Value Quantization — defensible math

        
We sell capital preservation, not “AI.” Every dollar claim has to survive a CCO whiteboard. Each
          intercepted breach has three cost streams:

        

          $$V_{\text{retained}} = \underbrace{P(\text{inq}|b)\,E[F]}_{\text{regulatory exp.}} +
          \underbrace{H_{\text{rem}}\,W_{\text{ops}}}_{\text{remediation labor}} +
          \underbrace{s_{\text{bps}}\,N\,P(\text{impact})}_{\text{adverse market drift}}$$
        

        
Default assumptions (all editable in code, displayed in Tab 01 KPI panel):

        
    
          
  • \(P(\text{inq}|b) = 0.12\) — probability an unhandled breach triggers a regulator inquiry (FINRA
            settlement priors).
    • 
          
  • \(E[F] = \$850\text{K}\) — expected fine, recent IPS-breach FINRA averages.
    • 
          
  • \(H_{\text{rem}} = 2.4\,\text{hrs}\), \(W_{\text{ops}} = \$285\)/hr loaded.
    • 
          
  • \(s_{\text{bps}} = 18\) bps adverse drift in remediation window, \(P(\text{impact}) = 0.60\).
    • 
          
  • \(N\) = order notional in USD — the only per-trade variable.
    • 
        

      


      

        
III. Upstream Data Strategy — Persia’s lane

        
Legacy compliance data is degraded and non-standardized. Statisticker is forward-facing: it mirrors live
          order flow against forward rules, explicitly bypassing historic data cleanup in phase one.

        
Sandbox & Diligence Targets

        
    
          
  • Dual-path workflows: investment-team (research, IC notes) vs client-side (onboarding, IPS,
            execution).
    • 
          
  • Synthetic IPS corpus: 8–10 statements across mandate types with nuanced restrictions.
    • 
          
  • FFIEC controls + audit log + regulator-export answer set a CISO can ask through.
    • 
          
  • OFAC SDN + FINRA 4111 + ERISA 404/406 mapped to specific parser rule classes.
    • 
        

      


      

        
IV. 30-Day Plan — honest version

        
A strategy engineer, a JD in compliance, and JD the marketer, working together to make this happen with
            equal measure.
          The phasing below is what is actually
          shippable
          in a part-time-Mash +
          part-time-Persia + JD-on-demand cadence. The original 30-day deck implied a full-time team; this
          doesn’t.

        
Phase 1 (Days 1–10) · demo-grade end-to-end

        
    
          
  • Live `/api/parse-ips` via Vercel serverless, OpenAI-backed with strict schema; deterministic fallback.
          
    • 
          
  • Audit-log JSON-LD export.
    • 
          
  • 8 IPS templates validated by Persia.
    • 
          
  • 2 warm-logo discovery meetings (JD).
    • 
        

        
Phase 2 (Days 11–20) · real anomaly layer

        
    
          
  • KDE fit + IQR outlier scoring on synthetic per-desk feature stream.
    • 
          
  • FIX-tap reference adapter (read-only OMS sidecar) prototyped on a single venue mock.
    • 
        

        
Phase 3 (Days 21–30) · pilot-pitch loop

        
    
          
  • Post-feedback iteration on parser & ensemble rationale UX.
    • 
          
  • Pitch v1.0 deck + interactive walk-through script.
    • 
          
  • Pilot LOI or paid POC scoped with one warm logo.
    • 
        

      

    

  


  
  

    

      ENSEMBLE: gemma3-4b // deepseek-v3 // qwen2.5-math-7b // llama-3.1-8b // kde-anomaly
    

    

      BUILD: STAT-v0.2.2026.05.23 · statisticker.net