What is Agent quant
In traditional quant, a human writes the strategy. In Agent quant, the agent does the research. The bar moves from “can write Python” to “can ask” — but so does the bottleneck: it is no longer whether the strategy is right, but whether the agent made it up.
Agent quant = letting the agent run the whole loop — hypothesise → fetch → backtest → validate — while the human only asks and adjudicates. What it needs is not more data, but checkable data — because when an agent is wrong you cannot tell what it computed from what it invented.
How it differs from traditional quant
This is not the same job done better — it is a different executor. Change the executor and the bar, the bottleneck and the platform’s role all change with it:
| Traditional quant (JoinQuant / RiceQuant / Uqer / MyQuant) | Agent quant | |
|---|---|---|
| Who researches | A human writes the strategy | The agent does the research |
| Who the data serves | Strategy code written by a human | The agent directly (MCP) |
| Barrier to entry | Can write Python | Can ask |
| Main bottleneck | Is the strategy right? | Did the agent make it up? |
| Platform’s role | Data + backtest engine + strategy community | Trustworthy data layer |
| Degree of automation | Human sets rules, machine executes | Agent proposes and validates on its own |
⚠️ The key distinction: “AI” on traditional platforms means an LLM helps you write strategy code (the human stays in the loop) ⇒ they build a Copilot. We build the base for an Autopilot — the agent completes fetch → hypothesise → validate → iterate on its own.
The sharpest edge: checkable
The biggest risk in Agent quant is not too little data — it is “the AI made it up and you did not notice”:
Traditional quant goes wrong: a human wrote the code, so you can debug it
Agent quant goes wrong: you cannot tell computed from invented
⇒ So what Agent quant really needs is not more data but checkable data. These design choices are not marketing — they are what makes an agent’s conclusion reproducible:
| Our design | What it means for the agent |
|---|---|
| K-lines are fixed to forward-adjusted, no `adjust` parameter, no gap on ex-dividend days | Returns the agent computes are reproducible — run it again later, same answer |
| Consistent units (yuan / share / lot spelled out) | The agent cannot get the order of magnitude wrong |
| Empty result ≠ failure | The agent will not read “no data” as “the service is down” |
| Fixed envelope `{ ok, endpoint, tier, elapsed_ms, source, data }` | The agent can tell for itself whether the call succeeded |
What the loop looks like
Agent quant is not “ask once, get a stock list” — it is a chain you can audit:
Expose data as tools the agent can call (MCP or REST) — not as web pages for it to read
The agent proposes: “after a volume breakout above the 20-day high, what is the 5-day hit rate?”
The agent calls tools for real data — structured, documented, reproducible
Adjudicate on statistical thresholds: enough sample, confidence-interval lower bound > 0, out-of-sample direction consistent
The conclusion does not match the data — this step is the real difficulty of Agent quant
Recompute from the raw data. Fixed conventions mean recomputation must match — fabrication shows up immediately
Our boundaries, up front
This page is about a category, not a promise. Three things we do not do:
We will not tell you which stock will rise. You get the data and the validation method; the call is yours.
We provide data and validation only — no order placement, no account access.
That is a returns promise aimed at retail. Ours is a capability promise for developers: how do you check what the AI said.
Ready to build
This page defines the category; these show how to do it:
Four data paths compared · REST and MCP routes · the four traps that fool a backtest
Fetch → backtest → adjudicate, with four adjudication rules
One URL into Claude Code / Cursor / Codex and more
FAQ
No. AI stock picking usually means a model hands you a list of tickers (a returns promise aimed at retail). Agent quant means the agent runs the whole research loop — fetching, computing and validating (a capability promise for developers). We do not promise picks; we guarantee the data is checkable and conclusions reproducible.
You can start. Agent quant moves the bar from “can write Python” to “can ask” — you state the hypothesis and the agent fetches and computes. But adjudication is still yours: is the sample big enough, does it hold out of sample.
In traditional quant a human wrote the code, so a bug can be debugged. In Agent quant the conclusion is generated, and when it is wrong you cannot tell computed from invented. Fixed conventions (forward adjustment, consistent units, a fixed envelope) are therefore not details — they are the precondition for using an agent for quant at all.
Yes. Single-stock / portfolio backtests and batch backtests across many symbols × many strategies, with commission / stamp duty / slippage / price limits. The strategy and factor libraries are callable too. See the MCP setup page.