From research spec to a live system

A strategy spec — a Pine Script file, a notebook, a page of rules — describes when to trade. A trading system has to answer a much longer list of questions, and most of the failures in live trading come from that list, not from the signal.

What a signal does not tell you

• Order lifecycle. What happens when an order is partially filled, rejected, or never acknowledged? What if the exchange times out after accepting it?
• Idempotency. If your process restarts mid-trade, will it place the same order twice? Every order needs a client-generated ID so retries are safe.
• State. Where do positions, open orders and P&L live, and how do they get reconciled against the exchange’s view after a crash?
• Data feeds. WebSocket streams drop. Reconnection logic must resubscribe, fill gaps from REST, and not trade on stale prices.
• Rate limits. Exchanges throttle and ban; requests must be budgeted and backed off.
• Secrets. API keys need least-privilege permissions (no withdrawals) and must never sit in code or logs.

Risk gates

Hard controls that sit outside the strategy logic and can override it:

• maximum position size and leverage per instrument,
• maximum daily loss and maximum drawdown, with an automatic halt,
• price-sanity checks (reject orders far from the last trade),
• a kill switch that flattens and stops everything.

Testing before money

1. Unit tests for indicator maths, so the Python port of a Pine Script indicator matches the original bar for bar.
2. Backtest with realistic costs — see an honest backtest.
3. Paper trading against live data, to catch timing, fill and data issues a backtest can’t show.
4. Small live size, compared trade by trade with the paper and backtest results.

Live trading should be an explicit opt-in switch, never the default.

The fast path: AgenKit

Doing all of this by hand is weeks of engineering for a solo researcher, which is why so many good ideas never leave the notebook. AgenKit packages a team of specialist AI agents — architect, test engineer, security, reviewer, DevOps — behind one command inside the coding tool you already use (Claude Code, Cursor, Codex and others).

You point it at any spec from the vault and it treats the spec’s maths and parameters as ground truth, then works through architecture, a test-first build, risk gating and review, pausing for your approval at each phase:

# once, in your project folder
npx agenkit install engineering-kit
npx agenkit memory build

Then in your coding agent:

/agenkit build a production-grade trading bot from strategies/<spec>.md
  with risk controls, a backtest engine, and paper trading by default

Every strategy page on quants.md has a pre-written command like this, tailored to the strategy type. Whatever you use to build, keep the checklist above: the signal is the easy part.