System architecture

This page is a technical structure overview of how NoahAI decomposes, verifies, and controls financial judgment. It is for understanding the end-to-end flow of judgment creation and verification, not individual algorithms or implementation detail.

NoahAI's core goal is not automation that replaces judgment but AI judgment infrastructure that structures, verifies, and explains financial judgment. We focus on operable trust (control, logging, explanation, verification), not short-term performance.

The architecture below shows the full flow from market/personal context input through judgment, guardrails (risk control), (optional) execution, logging/report, and feedback.

This page is not for explaining returns on specific assets or recommending automated trading. NoahAI technology is financial AI decision infrastructure built around judgment, risk control, logging, and verification; execution automation is always a separate optional option.

1

Market Data Layer

Market data input

We collect and standardize real-time market information: price, volume, volatility, order book. (News, filings, policy, etc. are extended in stages.)

2

Personal Context Layer

Personal financial context

We manage account/position state plus asset allocation, time horizon, risk tolerance, and behavior patterns. Judgment is organized in explainable form on top of this context.

3

Decision Layer

Agent judgment

We structure what to consider and why from collected data and personal context. When needed we present executable options; every judgment is logged and verifiable.

4

Risk & Guardrails

Risk control and guardrails

Conservative control rules (limits, halt conditions, max loss, prohibited rules, emergency stop) are applied first. The goal is controllability, not speed; we prevent abnormal behavior and excessive risk.

5

Execution Layer

(Optional) execution and automation

Within user settings and guardrails we automate repetitive work or provide executable options. Auto-execution is optional; default is judgment, logging, and explanation. Execution is atomic for consistency.

6

Logging & Report

Logging and reports

The full process (input, context, judgment, execution, result) is logged in a standard format and reports are generated for reproducibility and audit/traceability.

7

Feedback Loop

Feedback loop

Result analysis → policy improvement → next judgment. We aim for a judgment structure that accumulates experience, not fixed automation. Outcomes are accumulated at anonymized pattern level to improve system judgment policy over time and to improve safety and consistency.

External financial system integration

Current operation, integration, and extension:

Binance (standalone)

• python-binance–based standalone
• Binance Algo Order API (v3.8.9.9)
• TP/SL -2021 fix (v3.8.9.11)
• Advanced execution interface

CCXT integration

• Bybit, OKX, Bitget (futures)
• Upbit, Bithumb (spot)
• Unified decision support
• Per-exchange stats

Securities / ETF (extending)

• StockExchange interface (v3.8.9.11+)
• Domestic broker API integrated (operation/verification)
• ETF/equity UI complete (2026-01-18)
• Asset-class engine separation (crypto/securities)

Extension

• Overseas equities/futures (testing)
• Real estate (planned)
• Modular architecture for easy extension

Role of Analyst AI

NoahAI's Analyst AI is not a single model that makes judgment for you; it is a multi-module decision structure with separated roles to decompose, verify, and explain judgment from multiple angles.

Each module has distinct responsibilities (analysis, evaluation, risk control, verification) to minimize judgment bias and single points of failure and to present judgment in understandable form.

Core modules

The modules below are not a public API list; they are components of the decision infrastructure used inside NoahAI to perform financial judgment safely. Each module is designed for judgment, verification, and logging—not execution-first.

This set is designed as an Analyst AI structure with separated analysis, evaluation, risk, and verification roles to minimize bias and single points of failure.

1. analyzer.py – Market analysis and AI signal generation

  • Technical indicators: RSI, MACD, Bollinger, SMA/EMA, ATR, volume
  • Market regime: Volatility, trend strength, momentum, sentiment
  • Signals: Technical + AI-enhanced signals
  • Dynamic thresholds: Volatility thresholds by regime
  • Confidence: Technical + AI data + sentiment (0.0–1.0)

2. evaluator.py – Asset selection

  • Multi-dimensional score: Volatility (35%), trend (25%), volume (20%), frequency (10%), depth (5%), RSI (5%)
  • AI evaluation: Asset evaluation using AI learning data
  • Regime-based strategy: LOW/NORMAL/HIGH volatility
  • Hybrid: Caching + fallback + hardcoding for stability and performance
  • Optimization: Load 4min → near-instant; API dependency 100% → 30%

3. unified_trader.py – Orchestration and state

  • Multi-exchange: CCXT-based integration
  • Position monitoring: Per-exchange cycle (5–15s)
  • Execution policy: User settings and guardrails (halt, limits, exceptions)
  • Verification mode: Validate judgment and risk without live execution

4. ai_manager.py – AI learning and pattern

  • Market analysis: Regime and dynamic settings
  • Exit analysis: Exit timing optimization
  • Pattern verification: Pre-entry pattern (k-NN)
  • TP/SL analysis: Trade cause and improvement
  • Reports: Daily/weekly/monthly
  • Conversational AI: Natural-language assistant

5. recorder.py – Database and learning data

  • Persistent trade logging
  • AI learning data management
  • Statistics and performance

6. alpha_arena_trader.py – Alpha Arena (research)

Alpha Arena is a research/verification-only environment fully separate from live decisions and user assets.

  • LLM experiments: DeepSeek 3.1, Qwen 3 Max
  • Benchmark: nof1.ai Alpha Arena verification
  • Independent mode: Separate from main pipeline
  • Scope: Compare and replay engine/policy under same conditions

Extension points

This architecture is modular and can extend as follows:

  • Assets: Crypto → securities/ETF → real estate → everyday finance (transfers, checks, budgeting) on the same judgment–logging–verification structure.
  • Channels: Text → voice (accessibility) and step-by-step guidance for seniors and the digitally excluded.
  • Protection: Anomaly detection from context and behavior to mitigate fraud and phishing risk.

Related technical docs

Details of explanation, logging, and learning linked to this architecture are in the docs below.

XAI (explainable AI)

Decision rationale, traceable logs, reports →

Data structure

Schema and storage for judgment/result/context →

AI optimization loop

Record → Review → Policy → Risk → Feedback → XAI →

Technical proof

Operating pipeline and log examples →