Core Architecture

Built for operators who treat infrastructure as a competitive advantage.

Four architectural pillars. No external dependencies. No shared inference. No acceptable points of failure.

Local-FirstNo Cloud Routing
SovereignYour Data, Your Rules
VerifiableEvery Step Audited
ModularPlug, Extend, Integrate
DeterministicCode. Logic. Evidence.

Technology Architecture

Data & Market Inputs

Multi-source ingestion, normalized before anything downstream sees it

Market Data Broker Feeds News & Events Economic Data On-Chain Data Custom Sources

Cognitive Memory Layer (AAS)

Asset Administration Shells for trades, decisions, and outcomes β€” append-only, time-stamped

Trade AAS Strategy AAS Rule AAS Market Regime AAS Outcome AAS

Intelligence Layer (Local AI)

Perception only β€” no autonomous execution

Trend Scout Agent Business Advisor Agent Rule Checker Agent Risk Analyst Agent Local LLMs (Ollama)

Governance & Execution Layer

Deterministic, rule-based, fail-closed

Rule Engine Risk Engine Strategy Engine Execution Engine Human in the Loop

Broker & Execution Layer

Multi-broker support with reconciliation

Kraken Alpaca Saxo Binance IBKR + More

All orders, positions and balances reconciled in real time.

Audit Trail

  • Every decision logged
  • Every input versioned
  • Every action traceable
  • Every write append-only

Evidence Store

  • PostgreSQL
  • Append-Only
  • Timestamped & Versioned

Security Stack

  • No Cloud Routing
  • Local Inference Only
  • Encrypted at Rest
  • Encrypted in Transit
  • RBAC & API Keys

Technology Principles

Local-First AI

All models run on your infrastructure.

No Black Box

Every decision is explainable and reproducible.

Evidence-Driven

Trust is earned through verifiable outcomes.

Modular by Design

Agents and components are plug-and-play.

Open & Extensible

REST APIs power the dashboard today. Webhooks and a plugin system are on the roadmap.

Deterministic Execution

Strategies run in code, not in probabilistic text.

Tech Stack Highlights

PythonCore Platform
PostgreSQLAudit & Evidence Store
TimescaleDBMarket Data Time-Series
DockerContainerized Services
Ollamallama3.1 Β· qwen3 (Local)
PyTorchLocal ML Training (GPU)
FastAPIHigh-Performance API
SvelteKitTenant Frontend
Three.js3D Decision Graphs
WebSocketReal-Time Market Streaming
GrafanaObservability

Sovereign by Design

You own your data. You own your edge.

Transparent & Verifiable

Every step is logged. Every result provable.

Built for Professionals

For systematic traders who demand control.

Extensible Ecosystem

Integrate anything. Automate everything.

Technology that serves your decisions. Not the other way around.

Cognitive Memory Architecture

Institutional Memory That Compounds Over Time.

ZenTrader's Cognitive Memory Architecture is not a session cache or a conversation log.

Each analysis cycle produces a structured digital twin of the agent's decision state.

Cross-cycle continuity means that each new analysis is informed by the full history of prior decisions.

Private Intelligence Layer

Your Strategy Never Leaves Your Control.

ZenTrader's inference engine operates entirely within your deployment boundary.

There is no cloud routing path, no external model dependency, and no third-party API surface exposing your research context.

The result is complete inference sovereignty: deterministic outputs and immunity to provider-side model changes.

Local Inference. Total Sovereignty. Zero External Exposure.

Concurrency Guardrails

Simultaneous execution cycles are structurally prevented at the process boundary.

Policy-Gated Allocation

Every allocation decision passes through a sequential multi-layer preflight before any execution is permitted.

Cryptographic Boundary Defense

All broker credentials are cryptographically signed at the API boundary using industry-standard algorithms.

Modular Agent Orchestration

Three Isolated Stages. Typed Contracts. Designed to Evolve.

ZenTrader's core intelligence loop is composed of three independent, sequentially orchestrated stages.

Observation Stage

The first stage acquires, normalizes, and materializes market inputs into a frozen, validated snapshot.

Intelligence Stage

The second stage receives the validated snapshot and executes the full intelligence pipeline.

Memory Stage

The third stage receives a finalized intelligence result and handles all persistence.

Typed Contracts. Stage Isolation. Auditable by Design.

Narrative Intelligence Layer

Structured Evidence from Unstructured News.

News, geopolitics, and market narratives are converted into directional, decayed scores per asset and time horizon instead of staying free text an operator has to re-read every cycle.

Perception, Not Arithmetic

The model classifies each event against a fixed schema and must cite verbatim evidence for every factor it scores. A deterministic engine, not the model, computes the final number.

Calibrated Against a Golden Set

Every prompt or model change is graded against fixed reference events before it ships. Calibration history is published, not hidden behind a single confident-sounding demo.

Append-Only, Outcome-Verified

Re-scoring never overwrites a row. Realized price reactions are captured for every score above threshold, so predictive value is measured, never assumed.

Perception-Only LLM. Deterministic Scoring. Auditable Calibration.