TradeParity Lab

A GPT-5.6 and Codex-powered reliability toolkit that verifies algorithmic trading behavior across backtests, replays, simulated live runs, and broker execution.

Comment

Inspiration

Quantitative research is powerful, but most platforms assume that users already understand strategy code, backtesting, data leakage, transaction costs, and risk controls. I wanted to build a safer path for beginners: describe an idea in natural language, then let Codex help turn it into a professional, testable research workflow without connecting to a broker or risking real money.

During Build Week, I transformed an early reliability prototype into TradeParity Studio: a complete beginner-friendly quantitative research platform with strategy generation, backtesting, AI/ML research, and deterministic verification.

What it does

TradeParity Studio converts a natural-language strategy idea into a constrained Strategy Blueprint and reviewable Python Engine and Trade Manager candidates.

Before generated code can be used, the platform performs a security audit, enforces long-only behavior, blocks network and broker access, and prevents automatic execution.

Users can run configurable backtests and inspect:

  • Equity and drawdown curves
  • Benchmark comparisons
  • Transaction costs and trade ledgers
  • Risk limits and rejection reasons
  • Candidate-specific deterministic evidence

The reliability system runs the strategy through five independent execution paths. It compares all ten path pairs using canonical event streams and identifies the first semantic divergence when a fault is introduced.

The AI & ML Lab adds point-in-time feature audits, purged time splits, a logistic-regression baseline, research gates, and an optional GPT-5.6 structured shadow factor. AI output is advisory only and cannot override deterministic gates or create order intent.

How I built it

The core is a standalone Python package with stable plugin contracts for strategy engines and trade managers. The graphical Judge Console is implemented with self-contained HTML, CSS, and JavaScript and is served only through a local loopback research workbench.

Judge Mode runs completely offline using versioned synthetic fixtures. It requires no account, API key, market-data subscription, or network connection.

The optional OpenAI integration uses the Responses API with strict structured output, store=false, and a narrowly defined schema. Online market data is optional, read-only, disabled by default, and stored only in an excluded local cache.

How I used Codex and GPT-5.6

Codex was my primary engineering collaborator. It helped me design the plugin contracts, deterministic evidence format, generated-code safety audit, configurable backtesting workflow, graphical interface, documentation, tests, and release validation.

I used GPT-5.6 through Codex to reason about architecture, safety boundaries, failure modes, and the product experience for beginners. GPT-5.6 is also integrated as an optional structured shadow-factor provider, while deterministic code remains the final authority.

I made the key product decisions: the platform must remain broker-free, long-only, independently runnable, safe for generated code, and useful without credentials or private data.

Challenges

The hardest challenge was balancing accessibility with professional research discipline. Natural-language generation is easy to demonstrate, but generated trading code must be treated as untrusted.

Another challenge was proving that results were reproducible. Simple output comparison was not sufficient, so I added canonical JSON snapshots, input and code hashes, frozen seeds, stable event ordering, five independent paths, and first-divergence reporting.

Accomplishments

  • Natural-language strategy design and audited code generation
  • Candidate-specific configurable backtesting
  • Five independent execution paths with 10/10 pairwise verification
  • Equity, drawdown, benchmark, cost, and trade-ledger reporting
  • Point-in-time-safe ML research and validation gates
  • Optional strict-structured GPT-5.6 integration
  • 79 automated tests, package security auditing, and GitHub Actions validation
  • A complete offline, one-command Judge Mode

What I learned

I learned that AI is most valuable in quantitative research when it expands what a beginner can build while remaining constrained by deterministic evidence, explicit risk rules, and human review.

What's next

Next, I would add more licensed read-only data providers, additional strategy templates, stronger sandbox isolation, richer robustness testing, and guided explanations that teach beginners why a strategy passed or failed—while preserving the broker-free and human-controlled safety boundary.

Built With

Share this project:

Updates