Research before risk

What if an AI agent could sit beside you inside a professional trading terminal—not merely talk about a chart, but investigate the same market, run the same experiment, and show every action while you remain in control?

PaperQuant Lab turns one natural-language hypothesis into visible, reproducible crypto research. A human opens the live laboratory and asks Codex to investigate. Codex discovers 22 typed WebMCP tools attached to that exact page, configures the chart, gathers market evidence, launches a deterministic historical study, explains what passed and what did not, and overlays the signals for the human to inspect.

No hidden browser clicking. No pixel scraping. No real money.

The problem

Trading learners and quantitative researchers face a fragmented workflow:

• inspect a chart in one product;
• copy prices into a notebook;
• write or run code elsewhere;
• manually reconcile signals, assumptions, and P&L;
• trust that the agent understood the same state the human saw.

Conventional browser agents make this worse on dense trading screens. They infer controls from the DOM, lose semantic context, and can silently drift away from the market, timeframe, indicator set, or account state the user intended.

PaperQuant makes the trading laboratory itself agent-native.

The judge journey

Open the laboratory and ask:

Give me the read-only observer URL. Set BTCUSDT perpetual to 1h, enable Hull Suite, VWAP, RSI and ADX, inspect completed candles, order-book depth and recent trades, then run the BTC filtered EMA study from 2023-01-01 through 2025-12-31 with $100,000 research capital. Poll it, explain technical status, data quality and profitability separately, and overlay its markers. Do not change my paper account.

PaperQuant then performs a complete, inspectable research loop:

1. Discover — Codex reads the page's live capability contract.
2. Configure — market, instrument, timeframe, and multiple indicators change atomically in the visible UI.
3. Inspect — completed candles, indicator values, liquidity imbalance, and aggressor flow become structured evidence.
4. Research — an asynchronous, checksum-keyed strategy run executes on historical Binance data.
5. Explain — technical status, data quality, assumptions, annual results, walk-forward performance, and profitability are reported separately.
6. Show — buy, sell, short, cover, stop, and target markers appear on the same chart.
7. Protect — the paper account remains unchanged unless the human explicitly requests a simulated order.

Every agent operation appears in a collapsible, sanitized workflow console. A high-entropy observer URL mirrors the session read-only in a second tab or device, making human-agent collaboration visible rather than hidden behind a chat response.

Why WebMCP is essential

PaperQuant does not expose a thin demo command or a second agent-only backend. The top-level document registers 22 strict-schema tools through document.modelContext.registerTool, and every handler calls the same typed application controller used by the React interface.

The tools cover:

• capability discovery and market search;
• Spot and USD-M perpetual market context;
• atomic multi-indicator chart configuration;
• completed-candle and signal inspection;
• order-book and aggregate trade-tape evidence;
• paper account, order, prediction, and history operations;
• strategy discovery, save, run, poll, cancel, regression, artifact, and chart-overlay operations.

This is the core WebMCP advantage: the page publishes stable domain operations instead of asking an agent to guess what pixels mean.

The implementation includes strict JSON Schemas, bounded inputs, structured success/error envelopes, cancellation and cleanup, read-only and untrusted-content annotations, idempotency keys for retryable writes, and explicit user-intent gates for simulated financial mutations. Navigating away removes the tools cleanly. Without WebMCP, the normal human interface remains fully usable.

A complete product, not a proof of concept

The live build includes:

• real Binance public quotes, depth, aggregate trades, and 1m–1M candlesticks;
• active USDT market search across Spot and USD-M perpetuals;
• expandable candlestick charts and multi-indicator overlays;
• Hull Suite ribbon, VWAP, EMA/SMA, Bollinger Bands, Supertrend, Ichimoku, RSI, MACD, Stochastic RSI, ATR, and ADX/DMI;
• a versioned paper account with long/short positions, reduce-only behavior, funding entries, idempotency protection, and a maximum 2× simulated leverage ceiling;
• 20 versioned strategy hypotheses with a full regression report;
• annual and rolling walk-forward performance, trade ledger, equity curve, assumptions, provenance, scientific hashes, and immutable compressed artifacts;
• browser-isolated Python signal experiments;
• D1-backed owner sessions, read-only observation, quotas, and a live workflow console.

The interface is designed so a first-time judge understands the product immediately, enters the laboratory in one click, and sees Codex and the human sharing the same state.

Research integrity over impressive-looking numbers

PaperQuant refuses to turn missing data into fake confidence.

Signals are evaluated on completed UTC candles and filled no earlier than the next candle open. Fees, spread, slippage, and funding are separated. Risk sizing and maximum leverage are enforced. When stop and target occur in the same bar, the conservative stop-first rule wins.

A strategy result has two independent questions:

• Did the engine and rules execute correctly and reproducibly?
• Did the strategy make money?

PASS answers the first question, never the second. Data gaps produce PARTIAL_DATA; fundamentally unavailable history produces BLOCKED_DATA. Blocked strategies remain visible in the 20-row report instead of disappearing or receiving fabricated performance.

This honesty is especially important for learners who may otherwise mistake an attractive backtest for evidence of a safe strategy.

Safety by construction

Every balance, fill, fee, funding entry, and profit-and-loss value is simulated.

PaperQuant has:

• no private exchange API keys;
• no deposits or withdrawals;
• no real-order pathway;
• no account mutation from a backtest;
• no paper trade without explicit user intent;
• exact confirmation requirements for destructive reset operations.

Exchange and strategy output is treated as untrusted content and cannot authorize a later action.

Architecture

The Vinext/React application runs on ChatGPT Sites. Binance public APIs provide live market data. Sites D1 stores sessions, strategies, quotas, idempotency records, and compact research metadata. Sites R2 stores immutable artifacts. A separate authenticated Python worker retrieves and verifies official Binance archives, runs deterministic studies, and returns compact results plus compressed evidence without receiving Sites storage credentials.

The result is a credible end-to-end product: live browser tools, shared UI state, asynchronous quantitative workloads, provenance, safety controls, and repeatable tests.

Why it can matter

PaperQuant begins with crypto education, but the interaction model applies anywhere a high-stakes expert interface must become safely operable by humans and agents together: finance, operations, scientific instruments, analytics, and engineering consoles.

WebMCP lets the website become the trusted collaboration boundary. The human keeps context and authority; the agent gains typed capabilities; the product records the evidence.

PaperQuant does not ask users to trust an AI trader. It gives them an AI research partner whose work they can watch, reproduce, and challenge before risking anything.

Created by Sourav Bera — Head of Tech at QuarqLabs.

Built With

• binance-public-data
• chatgpt-sites
• cloudflare-d1
• cloudflare-r2
• codex
• lightweight-charts
• pytest
• python
• react
• typescript
• vinext
• vitest
• webmcp