Can a Vision Model Read a Chart Well Enough to Bet on It?PHASE 1.5 · STUDY

TRAIL Lab · Phase 1.5 (Vision Mode) · 2026-06-13 · ~8 min read · N = 24 resolved legs · 13 ticks · 1 OTC symbol · 7 minutes wall-clock

1. TL;DR — one paragraph, one number, one warning

Live session: 6a2daaee03417038f3134394 · started 19:09:34Z · symbol USDSGD (OTC via Pocket Option screen capture) · horizon 120 s · ¼-Kelly · spread 8 bps · slippage 2 bps · execution delay 120 ms · bankroll start $100.

2. Why we built a second mode

Phase 1 of the TRAIL Lab shipped a friction-honest backtest harness on real OHLC bars (Polygon, Databento). It worked. It measured the TRAIL coefficient on EURUSD, BTCUSD, NQ futures — instruments where we own a candle stream. The problem revealed itself the first time the operator pointed at a Pocket Option OTC chart and asked the same question: does the edge survive friction here?

We have no OHLC contract for Pocket Option's synthetic OTC feed. We never will. Pocket Option's OTC is a proprietary, broker-internal price series manufactured for weekend operation. The data does not exist outside the broker's tab. And yet — that is precisely the venue where retail binary operators trade, where the "80% hit rate" claim that motivated Phase 1 originated, where the engineer's intuition was formed. Building a friction lab that cannot evaluate the venue the question came from is academic nicety, not engineering.

The phase-1.5 thesis was simple: if the broker's chart is the only ground truth available, then the broker's chart — as pixels — must become the ground truth. The engine's input becomes the screen capture; the direction comes from a vision-language model reading the rendered candles; the close price comes from a second vision call at expiry; the rest of the TRAIL machinery (¼-Kelly sizing, asymmetric tilt, pristine/realistic double-entry book) stays bit-for-bit identical. The cost: ~3 seconds and one API call per leg open. The promise: "if you can see it, the lab can measure it."

This is a deliberate inversion. Phase 1 said "we trust the OHLC feed, we doubt the strategy". Phase 1.5 says "we doubt the perception layer too — and we are going to measure how much that costs."

3. The five hypotheses Phase 1.5 was designed to falsify

A study without falsifiable hypotheses is a press release. We pre-registered the following five, in writing, before the operator ran a single tick. Each has a numeric acceptance criterion and a numeric rejection criterion.

Note what we deliberately did not hypothesise: that the vision model would beat 50/50 on direction. That is a strategy claim, not an infrastructure claim. Phase 1.5 is a measurement instrument; tuning the strategy is what the instrument is for.

4. Protocol — exactly what the run did

The operator opened the Pocket Option client to USDSGD OTC, 1-minute candles, default theme. They opened /trail-lab in another tab, left the VISION mode checkbox enabled (default-on for Phase 1.5), clicked Capture Screen, and dragged the selection rectangle around the candlestick canvas — including the most recent price digits at the right margin. They armed:

symbol            USDSGD          (label only — no OHLC feed used)
asset_class       vision
timeframe         1m
horizon_seconds   120             (each straddle expires 2 min after open)
bankroll_start    $100
kelly_fraction    0.25            (¼-Kelly cap)
spread_pct        0.0008          (8 bps)
slippage_bps      2
exec_delay_ms     120
vision_mode       true

They clicked auto-loop at 30 s cadence. Every 30 s the lab:

1. refreshed the chart capture from the existing screen-grab pipeline (re-rasterised the selected region);
2. POST /api/trail/observe with the PNG bytes;
3. backend handed the bytes to vision_extractor.py, which prompted GPT-4o for {direction, confidence, last_close};
4. engine opened a paired call + put straddle, sizes set by ¼-Kelly with an asymmetric tilt proportional to the extracted confidence;
5. 120 s later the watcher inside the auto-loop noticed each leg's expiry_ts, captured a fresh frame, and POSTed /api/trail/legs/resolve_with_frame;
6. backend extracted last_close from the fresh frame and atomically settled the leg via a CAS on (status=open) → (status=resolved, resolver_pid=$$).

No operator interaction occurred between arm and 7 minutes later when the operator pasted the headline numbers into the agent workboard. The run was halted not because anything failed but because 24 resolved legs + populated trail_coeff + 23 distinct closes was already past the acceptance bar for every hypothesis.

5. Results — every leg of the live USDSGD-OTC session

The full per-tick log below was extracted post-hoc from MongoDB collection trail_lab.trail_legs, session 6a2daaee03417038f3134394. Each row is one paired straddle (call leg + put leg, same tick_idx, identical entry_ts, identical entry_price). The "direction" column is the lab's inferred bet: whichever leg got the larger ¼-Kelly stake. The "actual" column is the realised sign of close − entry on the call leg (the put leg's close at the same expiry can differ by a few pips because the two close-vision calls happen ~3 s apart — see §7).

Ticks 9 and 12 were partially resolved at the moment the dump was taken (only one of the two legs had been settled by an auto-loop sweep yet); they are excluded from the per-tick W/L summary but their individual legs are included in the price-move statistics.
"dir" = direction the model bet (the leg that got the larger stake). "actual" = sign of (call close − entry). "✓?" compares those two. A row can still be profitable on a wrong directional read because the straddle pays the winning leg by 1× and loses 1× the smaller leg by capital sunk — see tick 3, where the lab's short bet on a +35 pip move still booked +$25 pristine because almost the entire stake sat on the put.

6. Findings — what each hypothesis actually returned

H1 — Plumbing

H2 — Camera is not stuck

H3 — Friction-honest invariant

H4 — Friction is small but real

H5 — Atomic resolution

The hypothesis we did not pre-register

7. Discussion — a 36% direction model is not a broken one

The temptation, looking at a single bankroll line that went $100 → $73 in seven minutes, is to declare the strategy dead. The lab specifically exists to make that call cheap. But three observations are worth keeping in mind before we let a 13-tick sample close the question.

7.1 — Sample size is laughable

Eleven directional ticks is not a study, it is a sanity check. The 95% CI on a 36% hit rate at n=11 includes everything between coin-flip-loser and coin-flip-winner. We need ~200 ticks before the CI even narrows to ±7 percentage points. The lab is now instrumented to collect that sample at ~2 ticks/minute; an overnight run produces ~1200 ticks. That is Phase 2's job.

7.2 — The straddle insures against direction errors

Notice tick 3 in the per-leg table: the model bet short, the realised sign was up by 35 pips, and the row still booked +$25 pristine. The mechanism: the asymmetric tilt put 85% of the ¼-Kelly stake on the put leg, but the call leg was still funded enough to capture the 2.6 pip move with positive P/L. The straddle is, structurally, a hedge against the engine being wrong about direction. It only loses when the model is both wrong and confident (tilt magnitude high, sign wrong) — and Phase 1.5 caught exactly that pathology in ticks 5–8, four consecutive 90%-confidence shorts during an upswing. The infrastructure faithfully recorded a real model-behaviour failure.

7.3 — The vision model has a systematic short bias on this asset

Of 11 directional ticks the model bet short on 10 of them. The realised path during the run had 5 down moves and 6 up moves on the call-leg close — i.e. roughly balanced. A model that always shorts a balanced random walk is a 50/50 model in expectation; in this particular sample the path happened to drift up after ticks 4–8, so the model paid for that drift. The right response is not to flip the sign — that just moves the bias — but to (a) ask whether the prompt biases GPT-4o toward "bearish" verdicts on green-on-black candle themes, and (b) calibrate the confidence: 0.90 confidence on a model that hits 36% is the actual defect, not the direction guess itself.

7.4 — Vision latency is the silent budget

Entry-side vision call: mean 3.4 s, max 4.2 s from entry_ts to _vision_extracted_at. Close-side vision call: mean 29 s, max 133 s after expiry_ts. The close-side latency is not the API — it is the auto-loop's 30 s cadence: the watcher only checks every 30 s, so on average a leg sits resolved-by-the-clock for 15 s before the loop sweeps it. That 30-second gap between expiry and resolution is also a window where the underlying price keeps moving, and the close vision call reads the price at resolution time, not at expiry time. This is a real systematic error and one the realistic book is currently not charged for — the friction model only sees spread, slippage, and execution-delay-at-open. Phase 2 must either (a) shorten the resolution-watcher cadence to ≤ 5 s, or (b) extend the friction model to include resolution_drift_ms.

8. Architecture sidebar — how four agents shipped this in 2 h 25 min

Phase 1.5 was, organisationally, an experiment in parallel agent work as much as a technical one. Four lanes ran simultaneously against pre-written contracts in TRAILLAB/PHASE_1_5_PLAN.md:

The non-obvious move was the stub bridge: at T=0 the orchestrator shipped a five-line dummy vision_extractor.py that returned {"direction":"long","confidence":0.6, "last_close":1.0} regardless of input. That stub let antigravity finish, test, and verify the engine's vision branch in isolation while claude was still writing the real extractor. When claude's real extractor landed, the dummy was replaced by a single import swap and zero code in the engine changed. Three lanes were able to run in true parallel for the first nine minutes; after that cursor was the critical path. Lesson: ship a contract-respecting stub on day 1 of any cross-agent file; never make a caller wait for a callee.

The orchestrator's tightest ruling was the missing-confidence policy at 18:18Z: when the vision model returns a price and a direction but no confidence, the extractor defaults confidence = 0.5 and the lab keeps ticking. This collapses ¼-Kelly to a symmetric straddle — no edge claimed, no edge missed, the friction clock keeps running. The alternative — hard-failing the tick — would have frozen the operator out of recoverable frames, which is the exact failure mode VISION mode exists to escape. Default to "no edge", never default to "no tick".

9. Limits, threats to validity, and what would falsify the result

• n = 13 ticks. Single session, single asset, single seven-minute window of Friday-evening OTC liquidity. Nothing here generalises until n ≥ 200 across multiple sessions and multiple symbols.
• OTC is not a real market. Pocket Option's USDSGD OTC is a synthetic broker-internal series. Findings here describe the lab's ability to evaluate that series; they say nothing about the same model on real USDSGD spot.
• No broker contract is being placed. Realistic-book P/L still assumes the lab gets filled at the spread-adjusted price after a 120 ms delay. On a real Pocket Option binary the payout structure is different (e.g. 80% return on a win, −100% on a loss) and the strategy's economics in that contract would have to be re-derived. The TRAIL coefficient as currently computed reflects spot-style P/L, not binary-option payout.
• Vision-model nondeterminism. GPT-4o at temperature > 0 will give slightly different answers to the same frame across calls. We did not run the same frame N times to estimate this jitter; Phase 2 should.
• Resolution-time drift. See 7.4 — the close vision call fires up to 30 s after expiry. This is a real systematic error that the current friction model does not charge for.
• Bias toward "short". 10 of 11 directional ticks bet short. Either the prompt steers GPT-4o that way, or the candles on USDSGD in that window were visually bearish, or both. Untangling this needs A/B prompts and a balanced-by-symbol test.

10. What Phase 2 should — and should not — try to prove

Phase 2 should:

1. Collect a real sample. Overnight run, ≥ 1000 ticks, ≥ 3 symbols. Stratify by symbol, by hour, by realised volatility regime. Publish the directional hit rate with a real confidence interval.
2. Calibrate the confidence. Reliability diagram: of all ticks where the model said 0.90, what fraction were right? If the curve is below the diagonal, the model is overconfident and tilt amplitude must be damped.
3. Tighten resolution latency. Resolution-watcher to 5 s cadence; one capture per expired tick used for both legs; add resolution_drift_ms to the friction model.
4. Run a binary-payout variant. Add an asset class where each resolved leg pays +0.8 × stake on a correct sign and −1.0 × stake on a wrong sign — the actual Pocket Option contract. The TRAIL coefficient on that variant is the number the original "80% hit rate" claim should be benchmarked against, not the spot variant.
5. Adversarial frames. Feed the extractor the same frame N=20 times; measure jitter in extracted price and direction. Anything > 5% direction-flip rate is a data-quality alarm.

Phase 2 should not:

• Tune the strategy on the 13-tick sample. There is no signal here, only setup.
• Add capital. The lab is, and should remain, a measurement instrument. Real money should only follow a friction-honest positive TRAIL coefficient across many sessions and many symbols, computed by an instrument that has been audited.
• Trust vision mode on OHLC-available symbols. If a feed exists, the OHLC path is bit-for-bit more accurate and cheaper than a 3 s vision call.

Closing

Phase 1 of the TRAIL Lab built an honest scale. Phase 1.5 built a way to weigh things the scale could not previously see. The scale now weighs a particular thing — GPT-4o's read of a Pocket Option OTC chart — and the weight, on the seven minutes we measured, was −$26.83 against a $100 starting bankroll, with a 36% directional hit rate. The scale itself is honest: pristine ≥ realistic, friction reconciled, atomic resolution, camera not stuck. The weighed object is, on this sample, lighter than expected. The next step is to weigh it for longer.

The lab is now ready to do the boring, important thing it was built for: collect samples and compute coefficients until the question "does the paper edge survive friction?" can be answered with a confidence interval instead of a vibe.

TRAIL Lab · Phase 1.5 Study · 2026-06-13 · data: trail_lab.trail_sessions._id = 6a2daaee03417038f3134394 · 24 of 26 resolved legs analysed (2 still in-flight at dump time) · methodology whitepaper: trail_lab_whitepaper.html · related: hybrid engine, divergence lab.