FinRL-X: AI-Native Trading Architecture

• FinRL-X is an AI-native, modular trading system that unifies data processing, strategy construction, backtesting, and execution via a target portfolio weight vector.
• It features a four-layer architecture—data, strategy, backtesting, and execution—that standardizes quantitative trading across research, paper trading, and live deployment.
• The weight-centric interface decouples strategy logic from broker-specific orders, enabling modular composition of both rule-based and AI-driven components.

FinRL-X is an AI-native, modular, deployment-consistent trading architecture that unifies data processing, strategy construction, backtesting, and broker execution under a weight-centric interface. Its central abstraction is the target portfolio weight vector $w_t \in \mathbb{R}^n$, treated as the sole interface contract between strategy logic and downstream evaluation or execution modules. On that basis, FinRL-X organizes quantitative trading as a composable pipeline spanning stock selection, portfolio allocation, timing adjustment, and portfolio-level risk overlay, while preserving common semantics across research, paper trading, and broker-integrated execution (Yang et al., 22 Mar 2026).

1. Lineage within the FinRL ecosystem

FinRL-X emerged from a broader FinRL trajectory that had already standardized financial reinforcement learning as a layered software problem rather than only an algorithmic one. The earlier FinRL framework defined a three-layer architecture—application, agent, and environment—and positioned financial trading as a modular DRL workflow with Gym-style environments, reusable agents, and canonical tasks such as stock trading, portfolio allocation, and cryptocurrency trading (Liu et al., 2021). FinRL-Meta then shifted the ecosystem toward a data-centric substrate, emphasizing dynamic datasets, automated data curation, standardized market environments, and a training-testing-trading pipeline designed for nonstationary financial data (Liu et al., 2023).

Within that lineage, FinRL-X is best understood as an architectural extension from model-centric and environment-centric workflows to system-level deployment consistency. Earlier FinRL work primarily standardized how to define environments, train agents, and benchmark strategies. FinRL-X instead places the interface between research-time strategy logic and deployment-time execution at the center of the design. This reorientation is visible in its explicit concern with the backtesting-to-paper-trading gap and the paper-trading-to-live-trading gap, and in its attempt to preserve the same downstream object—target portfolio weights—across all stages of the pipeline (Yang et al., 22 Mar 2026).

This positioning also clarifies a common misconception. FinRL-X is not presented as a replacement for FinRL or FinRL-Meta; rather, it extends the FinRL family from DRL experimentation infrastructure toward an end-to-end trading system in which data ingestion, strategy construction, evaluation, and broker execution are deliberately aligned. A plausible implication is that FinRL-X functions as the deployment-oriented systems layer above the earlier environment and benchmark layers.

2. Weight-centric interface and deployment consistency

The defining abstraction of FinRL-X is the weight-centric interface. Instead of letting strategy modules emit broker-specific orders, buy/sell labels, or arbitrary signal values, FinRL-X requires strategy logic to output a target portfolio weight vector,

$w_t \in \mathbb{R}^n,$

which specifies desired capital allocation across assets at time $t$ (Yang et al., 22 Mar 2026).

The paper attributes three system-level benefits to this choice. First, it decouples strategy logic from broker-specific order semantics. Second, it enables composability across heterogeneous modules, because rule-based, optimization-based, reinforcement-learning-based, and LLM-derived components can all communicate through the same target-weight contract. Third, it improves deployment consistency, because both backtesting and live execution consume the same formal object (Yang et al., 22 Mar 2026).

This design is formal rather than rhetorical. FinRL-X explicitly states that the target weight vector is the sole interface contract between strategy logic and downstream evaluation or execution modules. The paper also formalizes the deployment problem as

$$\mathcal{S}_{research} \neq \mathcal{S}_{paper} \neq \mathcal{S}_{live},$$

thereby rejecting the stronger claim that research, paper, and live environments are identical. FinRL-X does not claim to eliminate this mismatch; it claims to reduce it by preserving interface consistency and aligned execution semantics across stages (Yang et al., 22 Mar 2026).

That distinction matters. A second common misconception is that a weight-centric protocol automatically solves execution realism. The paper does not make that claim. It instead argues that architectural consistency makes discrepancies diagnosable and reduces the need to rewrite strategy logic when moving from backtest to broker-connected deployment.

3. Four-layer architecture

FinRL-X is organized as a four-layer architecture: data layer, strategy layer, backtesting layer, and execution layer (Yang et al., 22 Mar 2026).

Layer	Core function	Named integrations or examples
Data layer	Ingestion, normalization, calendar alignment	FMP, structured data, news, LLM-based preprocessing
Strategy layer	Selection, allocation, timing, risk overlay	Equal-weight, mean-variance, minimum-variance, DRL allocators
Backtesting layer	Offline evaluation under unified weight semantics	bt, transaction costs, slippage, event-driven order handling
Execution layer	Order translation, safeguards, reconciliation	Alpaca, structured logging, realized-allocation checks

The data layer supports both structured inputs—market, fundamental, and macro data—and unstructured news. Its two implementation principles are shared trading-calendar alignment and persistent storage of raw snapshots plus processed features, both intended to reduce mismatches between offline experiments and deployment. News is converted into structured sentiment signals through LLM-based preprocessing so that textual information can feed the same downstream strategy pipeline as numerical features (Yang et al., 22 Mar 2026).

The strategy layer is the architectural core. It decomposes strategy construction into stock selection, portfolio allocation, timing adjustment, and portfolio-level risk overlay. Each stage consumes either time-aligned information or an intermediate weight object and returns another contract-preserving object, with the final output always being executable target weights (Yang et al., 22 Mar 2026).

The backtesting layer reuses the same weight interface for offline evaluation via bt. The execution layer likewise reuses the unified weight interface, converting target weights into broker orders, applying safeguards, and logging realized allocations for post-trade consistency checks. Alpaca is the named broker integration used in deployment validation (Yang et al., 22 Mar 2026).

This modular layering is closely related to earlier FinRL abstractions, but the semantic emphasis differs. FinRL largely separated application, agent, and environment concerns (Liu et al., 2021), whereas FinRL-X separates research and deployment responsibilities while forcing them to communicate through a common executable representation.

4. Strategy composition and mathematical structure

FinRL-X formalizes the strategy layer as a composition of transformations: $$w_t = \mathcal{R}_t\big(\mathcal{T}_t(\mathcal{A}_t(\mathcal{S}_t(\mathcal{X}_{\le t})))\big),$$ where $\mathcal{X}_{\le t}$ denotes time-aligned information available up to time $t$, $\mathcal{S}$ is stock selection, $\mathcal{A}$ is allocation, $\mathcal{T}$ is timing adjustment, and $w_t \in \mathbb{R}^n,$0 is portfolio-level risk overlay (Yang et al., 22 Mar 2026).

The tradable universe is denoted $w_t \in \mathbb{R}^n,$1, and the selection stage produces a candidate set

$w_t \in \mathbb{R}^n,$2

Selection can be driven by fundamentals or learned scoring models under strict no-lookahead semantics. Allocation then maps $w_t \in \mathbb{R}^n,$3 to feasible base weights $w_t \in \mathbb{R}^n,$4. Timing transforms those into $w_t \in \mathbb{R}^n,$5 using trend-based or learning-based signals, and risk overlay maps timing-adjusted weights into final executable weights $w_t \in \mathbb{R}^n,$6, for example via VIX-based volatility scaling (Yang et al., 22 Mar 2026).

The paper’s “Weight-Centric Trading Pipeline” gives the operational sequence: $w_t \in \mathbb{R}^n,$7

$w_t \in \mathbb{R}^n,$8

$w_t \in \mathbb{R}^n,$9

$t$0

$t$1

This formulation is deliberately lightweight. The paper formalizes compositional structure and portfolio accounting, but it does not provide explicit mean-variance optimization programs, minimum-variance constraints, RL state/action definitions, turnover penalties, slippage equations, or a VIX-scaling formula (Yang et al., 22 Mar 2026).

That omission is substantive rather than incidental. FinRL-X is more a systems paper than a model-theoretic trading paper. It specifies the protocol by which modules must compose, but leaves most model-specific mathematics abstract. This has two consequences. First, it makes classical and AI-based components interchangeable as long as they output compatible weights. Second, it shifts the burden of model-level precision to individual modules rather than to the core framework.

5. AI-native but not AI-only

FinRL-X explicitly describes itself as AI-native, but it does not require an AI-only pipeline. Rule-based components such as equal-weight, mean-variance, minimum-variance, time-series momentum, KAMA, and VIX-based volatility scaling remain first-class citizens, while DRL allocators and LLM-based sentiment signals can be inserted without changing downstream execution semantics (Yang et al., 22 Mar 2026).

Within the FinRL-X paper itself, AI enters in two places. Reinforcement learning appears primarily in the allocation layer, where DRL-based policies are compared with classical allocators. LLMs appear in the data layer, where news text is processed into structured sentiment signals that can then inform selection, timing, or allocation (Yang et al., 22 Mar 2026). This division is important: FinRL-X does not frame LLMs as direct order generators, and it does not force RL to subsume the whole strategy stack.

Related research clarifies what such modular AI components could look like. FinXplore introduces a dual-agent architecture in which a PPO allocator over an existing universe is coupled with a DQN explorer over an extended universe, with acceptance based on incremental Sharpe improvement (Choudhary et al., 5 Sep 2025). This suggests a plausible FinRL-X extension in which the allocation layer is augmented by dynamic-universe expansion while downstream execution remains weight-centric. FineFT, in turn, combines an ensemble of DQNs, VAE-based capability-boundary estimation, and routing to a conservative fallback policy in leveraged futures trading (Qin et al., 29 Dec 2025). This suggests another plausible FinRL-X extension: an OOD-aware risk overlay or routing module that decides when a learned policy should not be trusted.

The same logic applies to financial LLMs. FinLoRA benchmarks LoRA-family methods for fine-tuning LLMs on 19 financial datasets and positions itself as an adaptation layer for open financial AI workflows (Wang et al., 26 May 2025). FEVO uses continued pre-training, supervised fine-tuning, and RL to produce stronger financial reasoning models, but its RL is used for LLM post-training rather than market decision-making (Pang et al., 8 Jul 2025). These projects are therefore complementary to FinRL-X’s LLM-based preprocessing path rather than substitutes for the trading architecture itself.

A third common misconception follows from the phrase “AI-native.” In the FinRL-X paper, AI-nativity means compatibility with RL allocators and LLM-derived signals inside a modular pipeline. It does not imply that every layer must be learned, or that classical quantitative methods are deprecated.

6. Backtesting, paper trading, and reported limitations

FinRL-X is evaluated from a system-level perspective on liquid U.S. equities and ETFs. The backtest period is January 7, 2018 to October 24, 2025; the paper-trading period is October 26, 2025 to March 12, 2026; and backtests assume proportional transaction costs of 10 bps per side. Reported metrics include cumulative return, annualized return, annualized volatility, Sharpe, Sortino, Calmar, maximum drawdown, turnover, drawdown duration, and win rate (Yang et al., 22 Mar 2026).

The principal backtest ablation compares allocators with and without timing. The reported result is that adding timing consistently improves risk-adjusted performance and often moderates drawdowns. For example, DRL without timing achieves cumulative return 2.33, Sharpe 0.55, and maximum drawdown $t$2, while DRL with timing reaches cumulative return 3.03, Sharpe 0.89, and maximum drawdown $t$3. Similar improvements are reported for equal-weight, mean-variance, and minimum-variance variants (Yang et al., 22 Mar 2026).

The paper also includes two use-case demonstrations under unchanged workflow semantics. “Rolling Strategy,” using all NASDAQ 100 constituents as candidates, top-25% selection, and DRL-based allocation, reports cumulative return 5.98, annualized return $t$4, annualized volatility $t$5, Sharpe 0.93, and maximum drawdown $t$6. “Adaptive Rotation,” grouping assets into Growth, Real Assets, and Defensive buckets with Information Ratio-based group selection and residual momentum within groups, reports cumulative return 4.80, annualized return $t$7, annualized volatility $t$8, Sharpe 1.10, and maximum drawdown $t$9, compared with QQQ cumulative return 4.02 and SPY cumulative return 2.80 over the same horizon (Yang et al., 22 Mar 2026).

Deployment validation uses an ensemble of Rolling Selection and Adaptive Rotation in Alpaca paper trading with daily rebalancing. The strategy reports cumulative return 1.20, total return $$\mathcal{S}_{research} \neq \mathcal{S}_{paper} \neq \mathcal{S}_{live},$$0, annualized return $$\mathcal{S}_{research} \neq \mathcal{S}_{paper} \neq \mathcal{S}_{live},$$1, annualized volatility $$\mathcal{S}_{research} \neq \mathcal{S}_{paper} \neq \mathcal{S}_{live},$$2, Sharpe 1.96, maximum drawdown $$\mathcal{S}_{research} \neq \mathcal{S}_{paper} \neq \mathcal{S}_{live},$$3, Calmar 5.09, and win rate $$\mathcal{S}_{research} \neq \mathcal{S}_{paper} \neq \mathcal{S}_{live},$$4, while SPY and QQQ record negative total return over that short paper-trading window (Yang et al., 22 Mar 2026). The paper is careful, however, to state that this horizon is not intended to establish statistically significant alpha. Its main purpose is to validate stable deployment behavior, broker connectivity, order routing, execution monitoring, and post-trade reconciliation.

The limitations are correspondingly architectural. FinRL-X does not provide explicit RL MDPs, optimizer constraints, execution-cost formulas, or exact overlay equations. Execution realism is discussed more than quantified. The paper-trading horizon is short, live-capital evidence is absent, and the presentation is centered primarily on equities and ETFs, with broader asset-class coverage deferred to future work (Yang et al., 22 Mar 2026).

For reproducibility, the paper states that the official implementation is available at https://github.com/AI4Finance-Foundation/FinRL-Trading, and it highlights persistent storage of raw snapshots and processed features, shared trading-calendar alignment, strict no-lookahead semantics, rolling out-of-sample validation, a unified strategy interface, and structured logging with post-trade reconciliation as its main reproducibility mechanisms (Yang et al., 22 Mar 2026).

In synthesis, FinRL-X is best characterized not as a single trading strategy, nor as an RL benchmark, but as a systems framework for quantitative trading in which heterogeneous strategy modules are composed under a common weight-centric protocol. Its historical significance lies in extending the FinRL ecosystem from reusable market environments and DRL workflows toward deployment-consistent research and execution infrastructure. Its technical significance lies in the claim that quantitative trading pipelines become easier to compose, compare, and operationalize when every module, learned or rule-based, ultimately speaks the same language: executable portfolio weights.