Generate code from a loose idea.
Fast output can hide undefined data rules, execution assumptions, risk limits, and success criteria. If the prompt is vague, the implementation is merely precise-looking ambiguity.
idea→generated code
AI-assisted algorithmic strategy workbench
Turn a trading idea into a strategy you can defend.
OpenQuant brings specification, SmartQuant C# implementation, backtesting, diagnostics, and research review into one local desktop workspace—ready for independent quants and lean investment teams.
- Windows desktop app
- SmartQuant strategy engine
- Local, inspectable artifacts
Spec is the source of truthEvidence, not AI guesswork
SpecCodeRunStrategy Log
strategy_spec.md · reviewed
Session momentum with controlled risk
1
Objective Capture persistent intraday momentum after the opening range.
2
Universe Liquid US equities; one active position per symbol.
3
Entry Breakout only when volume and spread filters agree.
4
Risk 35 bps maximum initial risk; flatten before close.
5
Acceptance Validate behavior across regimes, not PnL alone.
AI review · “Liquidity” is still ambiguous. Define the minimum dollar volume and maximum spread before implementation.
01 · SpecifyMake assumptions and acceptance criteria explicit
02 · ImplementConvert the approved spec into testable C#
03 · AnalyzeCompare observed behavior with intent
04 · ImproveVersion the evidence and next decision
AI, applied where judgment matters
Most AI trading tools rush from prompt to code. OpenQuant works on the part that determines whether the code is worth running.
Improve the strategy definition—then use code to test it.
AI helps you challenge and refine the specification first. OpenQuant converts the approved version to SmartQuant C#, runs controlled builds and backtests, investigates gaps in the evidence, and reports what the strategy actually did.
idea→specification→code→evidence→better spec
The key shift: code generation is a conversion step. The durable product of the AI collaboration is a clearer strategy and a better research decision.
One continuous workflow
From “what if?” to “here’s what happened.”
Three explicit phases keep research intent, implementation, and evidence separate—while every artifact stays together.
Turn intent into a behavioral contract.
Discuss the strategy in plain language while AI surfaces missing decisions across market data, signals, sizing, risk, sessions, orders, costs, and review criteria.
- No code or backtest distracts from the research question
- Assumptions and open questions stay visible
- The reviewed specification becomes the source of truth
strategy_spec.mdreviewed
01# Strategy specification
02
03## Entry behavior
04Signal: opening-range breakout
05Confirm: relative volume > 1.5
06Spread: ≤ 8 bps
07
08## Acceptance criteria
09Observe exclusions by reason
Build exactly what was approved.
OpenQuant uses curated local SmartQuant documentation, templates, and deterministic tools to create the C# strategy and configuration, compile it, and repair bounded implementation errors.
- SmartQuant-compatible C# and appsettings.json
- Visible source, config, diffs, and build output
- Take over and edit the implementation at any time
MyStrategy.csbuild succeeded
18public override void OnBar(Bar bar)
19{
20 if (!IsLiquid(bar)) return;
21 if (IsBreakout(bar))
22 Buy(positionSize);
23}
24
✓0 errors · 0 warnings
Ask whether behavior matches intent.
AI reads the structured report and implementation together. When the default evidence cannot answer the research question, it can add compact diagnostics, rebuild, rerun, and explain remaining uncertainty.
- Backtest results compared with specification rules
- Targeted debugging without silent strategy changes
- Actionable feedback for the next spec version
run_analysis.mdevidence sufficient
✓All acceptance checks observed
47trades
1.34profit factor
-6.2%max drawdown
The spread filter removed 18% of candidate entries, concentrated in the opening 10 minutes. Risk caps behaved as specified. Performance is sensitive to the volume threshold; create a new version before changing it.
All-in-one, out of the box
The research desk without the integration project.
Keep the strategy, data context, code, logs, reports, and AI discussion in one inspectable Windows workspace.
A complete strategy workspace
Projects, instruments, data, properties, source, configuration, output, strategy logs, performance reports, and discussion panes live together in a familiar desktop IDE.
Research-aware AI
AI reads the durable artifacts behind the strategy—not just the latest chat message—so follow-up work remains grounded in the reviewed spec and observed results.
Real SmartQuant projects
Generated strategies are normal SmartQuant C# projects you can inspect, edit, build, and run directly.
Visible changes
Review spec, source, scenario, and configuration diffs before accepting the next step.
Debuggable by design
Build logs, run logs, structured reports, and targeted diagnostics make failures explainable.
Built for serious builders
Professional rigor—without an institutional-sized stack.
Independent strategy developers
Move from a rough idea to a reproducible strategy without stitching together an editor, AI chat, build scripts, test harness, and result viewer.
Small hedge funds & prop teams
Give a lean research team shared discipline: explicit assumptions, versioned decisions, inspectable code, controlled runs, and evidence-backed reviews.
Experienced quants
Use AI where it saves real time—spec review, implementation support, failure analysis, and research feedback—while retaining direct control of every artifact.
Versioned research
Your strategy history should explain why—not just what—changed.
Each version connects the specification, code, configuration, build, run, analysis, and feedback. Branch an idea, compare evidence, and return to a prior decision without reconstructing the story from chat logs.
- v01Baseline specificationidea → reviewed rulesPF 1.12
- v02Add session filterfeedback → new spec → runPF 1.27
- v03Cap initial riskmechanics + acceptance updatePF 1.31
- v04Define liquidityspec reviewed · ready to buildpending
Questions, answered
What OpenQuant is—and isn’t.
Does OpenQuant just generate trading code?
No. Code generation matters, but it is the conversion layer between an approved specification and a testable strategy. OpenQuant puts more emphasis on improving the strategy definition and debugging it against evidence.
Do I need to be an expert C# developer?
No. You can begin in plain English and use the guided workflow. The C# stays visible and editable, so experienced developers retain full control and newer developers can inspect what is built.
Can AI silently optimize my strategy?
No. Analyze may add targeted diagnostics, but it does not silently change trading mechanics, risk rules, parameters, or simulation assumptions. Improvements return as explicit feedback for a new version.
Where does the work run?
OpenQuant is a local Windows desktop application. Strategy artifacts, builds, backtest outputs, logs, and reports stay in explicit local workspaces.
Is it only for solo retail traders?
No. It is designed for both independent developers and small professional teams that want institutional research discipline without assembling a large internal platform.
What trading engine does it use?
OpenQuant builds event-driven C# strategy projects on SmartQuant, with curated local documentation, templates, configuration, and controlled build/backtest tools.