Self-tuning vs static trading bots

"Self-improving" is one of the most over-promised phrases in retail trading software. It can mean something genuinely useful, or it can mean a system quietly torturing its own parameters until the backtest looks beautiful and the live account does not. The difference is not the marketing — it's the constraints. This page explains the spectrum, from fully static bots to unconstrained auto-optimizers, and where a disciplined design should sit. None of this is investment advice, a recommendation, or a promise of any outcome.

The static-bot problem: rules that never move

A static bot ships with a fixed set of parameters — entry thresholds, stop distances, position sizes — and runs them forever. There's an honest appeal to that: nothing can drift, what you backtested is exactly what runs, and there's no hidden machinery second-guessing the logic. For a strategy with a robust, slow-moving edge, static can be the right call.

The risk is regime decay. Markets are not stationary. A stop distance that was sane in a 2024-style chop can be too tight in a fast 2022-style bear, and a position multiplier calibrated to a quiet bull may oversize into volatility. The parameters that won yesterday's tape can slowly bleed against tomorrow's. A static bot has no way to notice; it simply keeps applying numbers that no longer fit. You can see this concretely in how a 3x ETF behaves across conditions — see how leveraged ETFs decay and leveraged & inverse ETFs for why fixed sizing on leveraged instruments is especially unforgiving.

The other failure: unconstrained "self-tuning" is just overfitting

The reflexive fix is to let the bot tune itself: re-run the optimizer on recent data, keep whatever numbers score highest, repeat. Done without hard limits, this is one of the most reliable ways to lose money slowly. An optimizer that can reach for any parameter value will happily memorize the noise in your recent fills — fitting the exact bumps of the last few weeks rather than any durable structure. The backtest curve gets gorgeous. The forward curve does the opposite, because the thing it "learned" was an accident of a small sample, not a repeatable edge.

This is the trap behind a lot of "AI-powered, always-learning" bot marketing. Learning that has no guardrails isn't adaptation — it's overfitting with extra steps. (For definitions of overfitting, profit factor, drawdown, and the other terms used here, see the trading-bot glossary.)

The disciplined middle: bounded re-fitting, guarded by hard clamps

There is a sane place between "never change" and "change anything." Coil separates self-improvement into two clearly different mechanisms, with very different powers — and neither is an open-ended optimizer let loose on your account.

1. The local learning pass — your machine, your closed trades, hard clamps

The copy of Coil on your machine (Mac or Windows) runs a small pass at each close (python3 -m coil_v4.learn) that leans position sizing — only sizing — toward what has actually been working in your own closed round trips. It tilts size by book (S&P 500 / Nasdaq-100 / Macro) and by buy-score tier — nothing else. Several constraints keep it honest:

• Hard clamps, twice. Each dimension's tilt is clamped, and the stacked product is clamped again to roughly 0.55×–1.35× overall. The pass can nudge a multiplier inside that band — it can never wander to an extreme value that would have looked great on noise.
• Shrinkage-weighted. Tilts are shrinkage-weighted, so thin evidence barely moves the dials — one trade nudges it a hair, and it stays a neutral no-op until you have about two or more closed round trips behind it. It takes a history to move much.
• Size only — it cannot add structure. The pass adjusts sizing; it never touches entries, exits, stops, or caps, and it never invents a new entry condition, a new instrument, or a new rule. The validated rule-set is frozen and fingerprinted. Only the sizing dials move.
• Live round trips only. It learns from live fills only — the ledger is mode-isolated, so nothing tunes until you arm the engine and close real trades; dry-runs and backtests never feed it.
• Auditable. Every tilt is written to a readable log (optimization_log.json) — exactly what changed, by how much, and why — and the pass also surfaces diagnostics it never auto-acts on: which sectors, sleeves, and entry-quality bands have been paying or bleeding.

Because it's narrow, bounded, and offline, the local pass is a defense against decay, not a search for miracles. It runs on your own data, on your own hardware — your credentials and fills never leave the machine, and your history persists across packet updates, which is the same ownership principle behind the rest of how Coil runs.

2. New structure — a deliberate version you download, never auto-pushed

Discovering genuinely new structure — a new entry condition, a different exit behavior, a regime gate — is a different job, and it should never happen unsupervised on your live account. That work is done deliberately and re-validated on the research-backtest harness (point-in-time, survivorship-free, one fresh process per window — no cross-run cache warmth flattering the numbers) before anything ships. When a new version passes, it is announced on coil.trade and you download it manually, when you want it. There is no recurring charge and no central "sync" pushing changes to your machine — the download you bought is yours to keep and run forever, and installing a new version is always your choice, never something that arrives behind your back.

Static vs unconstrained vs disciplined — side by side

What the research backtest actually shows — and its limits

The figures below are a research backtest — point-in-time S&P membership with delisted names included (survivorship-free), next-open fills, costs modeled, 2017 through 2026 H1. They are the leadership-rotation backbone Coil's scoring is built on — not client returns, not live results, and not a prediction. The engine is newly live and will differ:

• The headline, with its benchmark: the backbone compounded +638% versus SPY's +282%, at a shallower worst drawdown (−23% vs −32%), and was positive in 9 of 10 years — the single down year was −1%, in 2018.
• The honest rider, stated plainly: through the end of 2025 it ran roughly even with SPY, just at about one-third less drawdown. The outperformance is not evenly spread — it concentrates in leadership regimes, where the strongest years land (2025 +51%, 2026 H1 +86%). Strip those out and the edge is a smoother ride, not a bigger number.
• Where the cash goes: on no-setup days the engine simply holds cash; idle cash earns whatever your broker's variable sweep pays (for example, Robinhood Gold quoted ~3.35% APY as of early 2026 — that is the broker's yield, variable, not paid by Coil, and not risk-free).

That shape is the whole thesis in miniature. The leadership-rotation structure that drives the strong regimes exists because it was designed and re-validated survivorship-free across a decade of windows, then shipped as a deliberate version — not because an unconstrained optimizer dialed numbers until the good years looked good in hindsight. And the honest rider is published on purpose: an edge that concentrates in certain regimes is a real edge with real limits, and you should size for both.

How to think about it

If a bot never adapts, ask whether its edge can survive a regime change. If a bot claims to always be learning, ask what stops it from learning noise — what the bounds are, whether it can invent rules unsupervised, and what happens when a change is wrong. The reassuring answers are narrow ranges, no autonomous structure changes on live capital, independent cold validation, and hard clamps the learning can never exceed — with every change written to an audit trail you can read. For how this fits the agent-and-broker setup, see automating trading with an AI agent, and remember the constant across every model: you own the keys, the capital, and the risk.