AI Research × Execution

The last mile of AI research

Models, factors and LLM agents propose ideas. Everything between a signal and a real fill — sizing, rebalancing, risk, execution, the ledger and reconciliation — is handled by one system. Keep your research stack and hand over the results.

The console, diagrams, screenshots and video currently use the Chinese interface. Blog articles and case studies are available in Chinese.

See integration options ★ GitHub · AlphaSpec open source Book an institutional demo

Research Contract Gate Paper Live Evidence Next version

strategy.alphaspec.json

{
  "contractVersion": "0.4",
  "kind": "artifact",
  "market": "cn_stock",
  "timeframe": "1d",
  "dsl": {
    "indicators": {
      "fast": { "type": "EMA", "period": 20 },
      "slow": { "type": "EMA", "period": 60 }
    },
    "entry": {
      "type": "CROSS_UP",
      "left":  { "ind": "fast" },
      "right": { "ind": "slow" }
    }
  },
  "exits": { "stopLossPct": 8 },
  "sizing": { "positionMode": "FIXED_PCT",
              "targetPctPerOrder": 20 },
  "producer": { "kind": "AI_AGENT",
                "searchTrials": 12 }
}

Open Contract

AlphaSpec: an auditable contract between AI and live trading

A strategy is not a piece of code but a declarative JSON document: which indicators, which entry and exit conditions, how stops and position sizes are set, and which market it trades. The specification, validator, indicator catalog and examples are open source under Apache-2.0.

Validated on the spot: you know whether the structure is right before submitting, not after a run
Built for LLMs: constrain the output with JSON Schema and every generated document is structurally valid
Easy to compare: see exactly which parameter changed between two versions, so iteration has a record
Review a document, not code: a document contains no executable code, so there is nothing to inject
Look-ahead stopped at compile time: a higher-timeframe indicator that reads unfinished bars is rejected on submission

The DSL is not our strategy language; it is the audit boundary between AI and live trading.

View AlphaSpec on GitHub →

Strategy document Rules, stops and targets, sizing, fill timing and universe — one document fully describes a strategy

Daily scores Your model outputs symbol → score every day; the platform builds the portfolio from ranks and weighting rules

Gate result Every check, its definition and why it failed, machine-readable

Execution evidence What actually happened after it ran, reported on consistent definitions

Four contracts Input, evaluation, runtime and feedback, each with a JSON Schema

Gate

AI generates in bulk, so the gate must be stricter

AI can produce hundreds or thousands of candidates in one go, and search alone produces good-looking backtests. So the gate never accepts the submitter's own numbers; the platform recomputes everything on the same definitions.

Evaluation windows set by the platform: in-sample plus the most recent out-of-sample period; the submitter cannot pick the range
Out-of-sample check: out-of-sample performance must not fall far below in-sample
Multiple-testing correction: a Deflated Sharpe correction based on the declared number of trials — the more you try, the higher the bar
Tradable as in reality: T+1, price limits, board lots and minimum commissions follow the real rules
Passing leads to paper only: a promoted strategy starts disabled and a person decides when to start it

The pass rate may be low, and that is exactly why it can be trusted. Institutions can send their own alpha through the same gate as an independent review before going live.

Signals from researchers, rules or AI follow the same path and pass the same gates.

Research Loop

How research connects to the system: real market results flow back to research

The real weakness of AI research is not the model but the missing loop: a model never learns what happened to its signals in the real market. The platform turns the execution evidence of every run into data research can read directly.

Did it run on time: whether the strategy is enabled, the rebalance executed and external scores are up to date
What was rejected: grouped by reason, each with advice on which document field to change, whether a person must act, or whether to wait
How far actual is from target: the model's target holdings compared with actual holdings after fills, symbol by symbol, with reasons down to board lots, price limits and T+1
What execution cost: slippage against the arrival price, the gap between paper and live for the same order, and fill rates
Every fill: a fill-by-fill ledger with the reason each order was placed

A diagnosis agent reads this evidence and answers why a strategy stopped working, then hands it to a researcher or a generation agent for the next version.

Research loop: research happens in your own stack; results reach the platform as AlphaSpec documents or daily scores, pass the gate into paper and live trading, and execution evidence returns through a diagnosis agent to the next round of research — Market data, news and research reports are available anywhere; real execution evidence only comes from a system that is actually running.

Migration

Strategy migration and integration: keep your research stack

Institutional teams have their own Python, LightGBM, PyTorch and feature libraries. They do not need to move, and they should not. Integration happens only at the output of research, in one of three ways.

① Scores only Your model outputs a set of symbol → score values every day; the platform handles sizing, rebalancing, execution, bookkeeping and reconciliation using ranking, weighting and risk rules. No changes to your research code — the fastest way to connect.

② Rule strategies rewritten Existing indicator rules (moving averages, breakouts, momentum, stops and targets, sizing) become one AlphaSpec document shared by backtest, paper and live trading.

③ Existing strategies exported and revised Strategies already running on the platform can be exported as documents, edited, resubmitted through the gate and published as a new version, with every version traceable.

Let the system handle the path from score to real fill

Sizing, rebalancing, risk, execution, the ledger and reconciliation take months to build in-house — and are exactly what research teams least want to build. Once connected, this part shares the same capabilities as every strategy on the platform.

One risk engine: pre-trade checks, budget reservation, strategy and portfolio circuit breakers that no source can bypass
One execution layer: algorithmic execution and multi-broker gateways with consistent definitions across backtest, paper and live
One ledger: cash, positions, NAV and performance attribution, reconcilable and auditable
Multiple markets: A-shares, ETFs, convertible bonds, futures, options, US equities and more, connected as needed

Three integration paths: daily scores only, rule strategies rewritten, existing strategies exported and revised, all passing AlphaSpec validation and the platform gate into one execution foundation — Three ways in, one execution foundation.

Agents

Any agent can connect, through the same gate

The platform is not tied to a particular agent. Our own AI research is only a reference implementation: teams can use it directly or connect the tools they already trust.

Three ways to connect: a Python package and CLI, an MCP server and Agent Skills, working with Claude Code, Cursor, Codex, WorkBuddy and other mainstream agents, and with LLMs such as DeepSeek and Qwen
Two Agent Skills: one writes and submits strategies, the other diagnoses strategies that are running
Layered permissions: reading market data, factors, backtests and execution evidence comes first; submitting and promoting must pass the gate; placing orders directly is never open
Institution accounts: administrators issue one agent account for the team with the same rights as a regular member, except it cannot start strategies
Individual developers: sign in with GitHub and create an API key yourself for backtesting and paper trading

Our own agents use only the public interfaces, with no internal shortcuts. Agents and people pass through the same gate — that is both the security design and the source of trust.

pip install alphaspec

# Install the Agent Skills (write + diagnose)
alphaspec skill --install ~/.claude/skills

# Validate offline, then submit for evaluation 
alphaspec validate strategy.json
alphaspec submit strategy.json --evaluate

# After it runs, see what actually happened 
alphaspec evidence --artifact 42

What agents can and cannot do

Permissions are layered by risk: the closer to real money, the more a gate and a human are required.

Capability	agent	Notes
Read market data, factors and the indicator catalog	Open	The same data permissions as a signed-in user
Submit strategy documents and upload daily scores	Open	Validated against JSON Schema and rules before submission; invalid documents are rejected on the spot
Backtest and gate evaluation	Recomputed by the platform	Windows are set by the platform, self-reported numbers are not accepted, daily quota applies
Read execution evidence	Open	On-time runs, rejection reasons with advice, target deviation, slippage, fill-by-fill ledger
Promote to a paper strategy	Gate required	Only strategies that passed the platform evaluation can be promoted, and they start disabled
Start or stop strategies	Not open	Confirmed by a person in the console
Place orders directly or change account-level risk settings	Never open	Orders come only from running strategies and pass the same pre-trade risk checks; a strategy's own risk limits live in its document and go through the gate with it