Industrial control plane, applied to trading

Why Industrie 4.0 architecture belongs in trading.

Most trading software is built by people from finance or SaaS, focused on finding an edge. ZenTrader's control plane comes from a different discipline: industrial automation.

Digital twin

Every strategy is wrapped in a standardized envelope, not a loose script.

Append-only

Gate decisions, reconciliation runs, and scores are written once, never overwritten.

Local inference

Ollama on local GPU hardware, TimescaleDB-backed. No cloud API sees your trades.

Inside the shell

What actually plugs into the digital twin.

Four input streams feed the strategy core. Two outputs leave it — broker execution and an append-only ledger. Nothing skips the shell.

Risk Parameters

Position Limits
Max Drawdown
Exposure Limits
Correlation Limits

Execution Telemetry

Orders & Fills
Latency Metrics
Slippage Analysis
Market Data Quality

Decision History

Signals Generated
Decisions Taken
State Transitions
Rationale & Scores

Market Context

Market Data
Regime Detection
Volatility & Liquidity
Economic Events

Strategy Digital Twin

Control shell

Signals

Risk Checks

Positioning

Adaptation

Interfaces & Contracts — broker-agnostic

GPU

Ollama Inference

TimescaleDB

Broker Adapters

Connectivity layer

Kraken LIVE PAPER

Alpaca LIVE PAPER

Saxo LIVE PAPER

IBKR LIVE PAPER

eToro LIVE PAPER

Custom / New Adapter READY

Append-Only Audit Trail

Immutable. Ordered. Verifiable.

Tamper Evident
Cryptographically Signed
Time Ordered
Regulatory Ready

Data & Context Flow Control & Feedback Execution Flow Append-Only Ledger

The pattern

The Asset Administration Shell, borrowed from the factory floor.

In Industrie 4.0, no machine is controlled directly — it is wrapped in an Asset Administration Shell (AAS), a standardized digital-twin envelope that separates a machine's logic from its physical connectivity, and gives every state change an auditable trail. ZenTrader applies the same pattern to a trading strategy.

A strategy is a digital twin, not a script

Risk parameters, execution telemetry, and decision history live in defined submodels — not scattered across log files an LLM has to guess its way through.

Logic is separated from connectivity

A strategy's mathematical core doesn't know whether its fills came from Kraken, Alpaca, IBKR, Saxo, or eToro. If a broker connection changes, the adapter changes — the strategy logic does not.

State is append-only

Every gate decision, reconciliation run, and narrative score is written once and never overwritten — the same principle AAS uses for machine history, applied to trading decisions.

Inference stays local

Classification and pattern analysis run on local GPU hardware via Ollama, backed by a TimescaleDB-based store — not a third-party cloud API that never sees, and never needs to see, your trades.

Honest limits

Not a fit for everything — and that's the point.

AAS-style encapsulation adds structure, not raw speed. High-frequency trading needs the opposite trade-off, so this is not built for microsecond execution. For systematic, swing, and daily-horizon strategies, the durability and auditability are worth far more than the overhead.

Where this fits

Systematic, swing, and daily-horizon strategies across multiple brokers.
Operators who need an auditable history of why a trade was allowed or blocked.
Anyone who wants local inference instead of sending trade data to a cloud LLM API.

Where this does not fit

Microsecond or high-frequency execution — the envelope adds structure, not raw speed.
Anyone looking for a signal generator — the shell governs a strategy, it does not invent one.

The honest summary: this is an industrial-automation control plane that happens to talk to brokers instead of machines.