Why AutoQuant runs on your machine

Most algorithmic trading platforms in 2026 are cloud apps. You sign up, you write a strategy in a browser-based editor, and that strategy lives on the platform’s servers. The platform owns the backtester. The platform owns the data pipeline. The platform owns the deployment runtime. The platform owns your code, in the practical sense if not the legal sense, because if you stop paying or the platform pivots, you lose access to your work.

AutoQuant is the opposite.

AutoQuant is a desktop application. You download an installer. You run it on your computer. Your trading strategies live on your hard drive at ~/.autoquant/strategies/ as plain Python files. Backtests run on your CPU. The AI Loop calls LLM APIs from your machine using your own API keys. Live trading orders go from your machine directly to your broker. Nothing about your strategies, your research, your AI prompts, or your backtest results passes through our servers. We have no copy. We can’t see them. We don’t train AI on them.

This is what “local-first” means in our context. Here is what it gives you, and why we built it this way.

Your code lives on your disk

Open Finder or Explorer and navigate to ~/.autoquant/strategies/. You will find your strategies there as Python files. They look like normal Python. You can open them in any editor. You can put them in git. You can email them to a friend. You can read them. You can modify them.

This sounds obvious if you came from writing software, but in the algorithmic trading platform space it is unusual. Most platforms wrap your strategies in proprietary formats, store them in databases you don’t have direct access to, or offer export only at their pace. AutoQuant treats your strategy code as what it actually is: a Python file on your disk.

If you stop paying for AutoQuant tomorrow, you still have every strategy you wrote. They are on your machine. You can run them with any Python backtester. You can rewrite them for a different platform. The work you did is portable in a way that platform-hosted code is not.

Backtests run on your CPU

When you click Run on a backtest, no request goes to autoquant.ai. The Python sandboxed execution runs locally. Market data is fetched from your configured providers (Yahoo Finance, Polygon, Alpaca) directly from your machine to their servers. The validation suite (walk-forward, Monte Carlo significance, deflated Sharpe, multi-symbol robustness) runs locally on your CPU.

This has practical consequences:

No throttling. You aren’t competing with other users for backtester capacity.
Fast iteration. Hot code, hot data, no network round-trip per run.
Backtests work offline. Once data is cached locally, you can backtest on a plane.
No “we’re upgrading our infrastructure” outages. Your computer is up if your computer is up.

AI runs from your machine, not through ours

This is the part most people get wrong about how AutoQuant’s AI features work.

When you trigger an AI Loop run, AutoQuant calls a language model API (OpenAI, Anthropic, Google, or your local Ollama instance) to generate candidate strategies. Those API calls go from your machine directly to your chosen LLM provider using your own API key. The prompts include your thesis description. The responses include the generated Python code.

We are not in the middle of any of this. AutoQuant has no relay server, no prompt logging, no model in the middle. We literally cannot see what you asked, what the LLM wrote, or what came out the other side. If you set up a local LLM via Ollama, no part of the AI Loop touches the internet at all.

This is fundamentally different from cloud-first algo platforms that have built AI features. On those platforms, your prompt goes to their server, which then queries the LLM provider, then runs the generated code on their backtester, and reports back. That intermediation creates a vendor with full visibility into everything you’re trying to do. We don’t have that.

The downside of our model: you pay your LLM provider directly for usage instead of paying us a flat monthly fee that includes some LLM credits. For heavy AI Loop users this might cost more, depending on which model you use. For light users it costs less. Either way, you control the spend.

Validation methodology you can read

The AutoQuant validation suite is the part of the product we are most opinionated about. Every backtest run produces walk-forward results, Monte Carlo significance, deflated Sharpe, multi-symbol robustness checks, and alpha-vs-SPY benchmarks. It is built in, not optional, not a separate paid tier.

Because the suite runs locally, you can read what it does. The code is open to inspection by paid subscribers. If you disagree with how we implement deflated Sharpe, you can see the implementation and challenge it. The validation methodology is not a black box.

This matters because the failure mode for a backtest is silent. You can overfit to a regime, pass an in-sample backtest with stunning numbers, and only discover the lie when you trade live and bleed. A validation suite that runs everything by default catches some of the worst overfitting traps before you commit capital. Doing that locally, where you can verify the implementation, builds the kind of trust that matters more than marketing copy.

What we don’t do, and why it matters

We don’t collect your strategy code. We don’t train AI on your data. We don’t take ownership of your work when you put it on our platform, because we don’t have a platform that ingests your work in the first place.

This is not a policy promise. It is a property of the architecture. We could not collect your strategies even if we changed our minds tomorrow, without re-architecting the product into a cloud-first system, which we won’t do.

The only things our servers see are:

License validation. When you start the app, it pings our license server to confirm your subscription is active. We see your license key, machine ID, and app version. We do not see your strategies or your trading activity.
Account management. Subscription billing goes through Stripe. We see your email and billing details. We don’t see what you do with the app.

That’s it. Everything else stays on your machine.

The honest tradeoffs

Local-first is not strictly better than cloud-first. The tradeoffs are real:

You have to install something. It is a desktop app, not a browser tab. We support macOS and Windows.
You are responsible for your own backups. If your laptop dies and you didn’t back up ~/.autoquant/strategies/, that work is gone. We are working on optional encrypted local backup but it is not shipped yet.
No multi-device sync. You write a strategy on your laptop, it is on your laptop. We don’t sync it to your other devices because syncing requires our servers to see your code.
You pay for your own LLM usage. No bundled AI credits. Direct billing relationship with OpenAI, Anthropic, or Google.

For some people these are dealbreakers and they should pick a cloud platform. For our audience, which is engineers managing their own capital and treating their strategy code as commercially valuable IP, these tradeoffs are the right ones.

Who this is for

AutoQuant is built for a specific person:

You are technical. You can read Python.
You manage your own capital, not other people’s money.
You take your strategy code seriously and consider it your IP.
You want to actually understand what your tools do, not just see results in a dashboard.
You are comfortable installing software and managing your own setup.

If most of these describe you, AutoQuant is built for how you want to work.

Try it

Free 14-day trial, full Quant tier access, no credit card required to start. Download at autoquant.ai.

The AutoQuant team