A QuantConnect alternative for AI-generated strategies

QuantConnect's value proposition is that you write your strategy inside their web editor, run it on their cloud, and — on paid tiers — deploy it live to your brokerage. The full lifecycle sits behind one login. That works very well if you're a quant who lives in the browser anyway.

But the way trading strategies actually get written has shifted. More and more, the first draft of a strategy is written by Claude Code, Codex, or Cursor — the developer asks the agent to draft something, iterates by talking, and only later reviews the code line-by-line. That workflow doesn't fit a browser IDE; it fits a local editor with an agent attached.

The minimum surface for AI-agent-driven backtesting is:

• Submit a Python strategy by passing source code over an RPC. No upload, no project structure, no project ID.
• Get back a structured result the agent can read. Not an HTML tearsheet — a flat JSON the agent can grep, branch on, or quote in chat.
• Manage credits and subscription from the same surface. Asking the user to open a dashboard to upgrade kills the flow.
• Quality signals the agent can act on without math. Booleans like small_sample, regime_dependent, and underperformed_benchmark, each with a reason and severity.

QuantConnect can do most of this through the Lean CLI + REST APIs, but the integration is bespoke per agent. The MCP protocol standardizes the discovery + auth + invocation surface — no custom tool definition per agent.

Being honest about the trade-offs matters. By choosing an MCP-native backtester, you give up:

• Live trading deployment. Bagtester is backtesting-only by design. To deploy a strategy you'll route through a separate execution stack.
• Deep options and futures coverage. Our asset surface is crypto / FX / US equities / ETFs, plus DOW-30 fundamentals and BTC funding. Options chains are not yet supported.
• Browser-based collaboration. Strategies live in your editor, not a shared web IDE. For solo or small-team work this is fine; for larger team-based research it might be a regression.
• Lean's primitives. Scheduled events, consolidators, and the Lean framework's broker-aware models don't exist. Most strategies don't need them, but if yours does, that's a real cost.

The flip side:

• Zero local setup. No Docker, no project scaffolding, no virtualenv. Add the MCP server once with one command.
• Structured agent-readable output. 107 metrics across 8 sections, 12 quality flags, 58 scoring features, sparkline previews, share URLs with OG cards.
• Subscription management from the agent. Cancel, upgrade, change payment method — all via manage_subscription MCP tool. No leaving the chat.
• Per-bar FX spread modeling. FX hybrid mode fills at ask (buy) and bid (sell), not mid — a detail that flips marginal-Sharpe strategies on cross pairs.
• Plain Python. Subclass bagtester.Strategy, implement on_bar(self, ctx, bar). No framework lock-in beyond the import.

Here's the same simple SMA crossover in both styles. QC version:

class SmaCross(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2024, 1, 1)
        self.SetEndDate(2024, 12, 31)
        self.AddCrypto("BTCUSDT", Resolution.Minute)
        self.fast = self.SMA("BTCUSDT", 20, Resolution.Minute)
        self.slow = self.SMA("BTCUSDT", 50, Resolution.Minute)

    def OnData(self, data):
        if not self.fast.IsReady or not self.slow.IsReady:
            return
        if self.fast.Current.Value > self.slow.Current.Value and not self.Portfolio.Invested:
            self.SetHoldings("BTCUSDT", 0.95)
        elif self.fast.Current.Value < self.slow.Current.Value and self.Portfolio.Invested:
            self.Liquidate("BTCUSDT")

Bagtester version:

from bagtester import Strategy

class SmaCross(Strategy):
    def __init__(self, fast=20, slow=50):
        self.fast, self.slow = fast, slow
        self.closes = []

    def on_bar(self, ctx, bar):
        self.closes.append(bar.close)
        if len(self.closes) < self.slow:
            return
        f = sum(self.closes[-self.fast:]) / self.fast
        s = sum(self.closes[-self.slow:]) / self.slow
        pos = ctx.position(bar.symbol)
        if f > s and not pos:
            ctx.buy(bar.symbol, ctx.equity * 0.95 / bar.close)
        elif f < s and pos:
            ctx.close(bar.symbol)

Same logic, smaller surface. Dates and symbol move from the algorithm body into the submit_strategy args — keeping the strategy pure and parameterizable.

If you need:

• Live deployment to brokers in the same platform
• Deep institutional asset coverage (options, futures with intra-bar greeks, real exchange data with consolidated tape)
• Collaborative browser-based research with multiple humans
• Lean's broader framework primitives

…QuantConnect is the right answer. Bagtester is a focused tool for the agent → backtest loop. The two coexist; they don't directly compete for the same job.

The fastest way to evaluate is to add Bagtester to whatever agent you already use:

• Claude Code setup
• Codex CLI setup
• Cursor setup
• Windsurf setup

500 credits/month free. Run a backtest, look at the JSON, see whether the flow fits.