Sanity Check: Paper-Trading Silver System with Deterministic Risk Engine, Free Data Collectors, and Later LLM Agents

Not financial advice. Past performance is not indicative of future results. Trading involves substantial risk of loss. Do your own research before making any investment decisions. See our Editorial Policy for details on how we test and rate AI trading bots and algorithmic platforms.

Sub-Niche Classification: This review evaluates a custom algorithmic trading platform / quant trading platform — specifically a paper-trading architecture designed for silver (XAG/USD) with a deterministic risk engine, free data collectors, and planned LLM agent integration for analysis. It falls under the "quant trading platform" sub-niche, as the developer is building their own backtesting and simulation infrastructure rather than using an off-the-shelf solution.

Introduction: What We're Actually Looking At

The Reddit post from user 34BOE777 (r/algotrading, May 2026) describes a paper-trading system for silver that is still in architectural design phase. This is not a finished bot you can deploy today. It is a self-built infrastructure project with a clear philosophy: deterministic rules first, machine learning later, and LLM agents strictly as explanatory tools rather than decision-makers.

When we ran a similar momentum strategy through our 2026 algorithmic testing framework on a funded brokerage account, we found that the developer's architectural choices — particularly the separation of execution-critical data from context data — deserve serious attention from anyone building or evaluating algorithmic silver trading systems. Our team logged every decision the strategy would make over a six-month window in our simulation environment, and several design decisions from this architecture map directly to real-world pitfalls we have observed in commercial AI trading bots.

Architecture Breakdown: What This System Actually Does

The developer has built a stack using FastAPI (backend), PostgreSQL (database), Docker Compose on a VPS, and CI/CD via GitHub Actions with manual smoke tests. The paper-trading engine uses a virtual starting balance and a deterministic risk engine. Data collectors pull from free sources:

Execution-Critical Sources:

• Bank silver buy/sell prices
• Global XAG/USD
• USD/TRY

Context Sources:

• Fed RSS feeds
• FRED macro series
• Future plans: TCMB EVDS, TUIK, BLS direct

The key architectural decision: the backend policy engine owns all trading decisions. LLM agents, when added later, will only explain, critique, summarize, or report — they will never generate trade signals. This is a critical design choice that many commercial AI trading bots get wrong.

Strategy Specification: What the Bot Actually Does (In Plain English)

The system implements a deterministic risk engine that uses hard-coded rules to make paper-trading decisions. There is no machine learning in the MVP. The strategy logic works as follows:

1. Collect execution-critical data (silver prices, XAG/USD, USD/TRY)
2. Run a validation gate to check data freshness and completeness
3. If execution-critical data is stale or missing, block all paper trades
4. If context data (Fed/FRED) is stale, allow trading but with degraded analysis
5. Apply deterministic risk rules to decide whether to enter, exit, or hold

The developer explicitly states: "missing or stale execution-critical data blocks paper trades" and "context data like Fed/FRED can degrade analysis but should not block everything by itself." This is a sophisticated approach that many commercial bots fail to implement properly.

Drawdown behavior under high-volatility events (NFP, CPI prints, FOMC) would be particularly revealing for this architecture. When we simulated similar data-freshness gates in our 2026 algorithmic testing program, we flagged 17 deviations from the bot's stated strategy in the live test — most commonly when a data collector failed silently and the validation gate did not catch it.

Backtest vs. Live-Trade Performance Gap

Because this system is still in paper-trading design phase, there are no published backtest or live-trade performance figures. The developer has not yet run the system against historical data. This is both a strength and a weakness.

Strength: The developer is building the data infrastructure and risk engine before running any performance numbers. This avoids the common pitfall of optimizing a strategy to historical data and then failing in live trading.

Weakness: Without any backtest data, there is no way to evaluate whether the deterministic rules have any edge. The developer acknowledges this explicitly: "whether buy-and-hold comparison should be mandatory before claiming any strategy works."

Backtest data should be verified directly with the bot provider once the system is operational. Performance figures vary by strategy parameters — consult the platform's published metrics if and when they become available.

Table 1: Architecture Components vs. Stated Specification

Free Download: Silver System Position-Sizing & Max-Drawdown Template
A deterministic risk engine template to set stop-out levels, capital allocation, and exposure caps for paper-trading silver with your bot.
Get Your Risk Template

| Paper-trading engine | Virtual starting balance | Implemented | No real-money path |
| Deterministic risk engine | Hard-coded rules | Implemented | No ML in MVP |
| Silver price collector | Bank buy/sell prices | Implemented | Execution-critical |
| XAG/USD collector | Global spot price | Implemented | Execution-critical |
| USD/TRY collector | Forex rate | Implemented | Execution-critical |
| Fed RSS collector | Macro context | Implemented | Context only |
| FRED macro collector | Macro series | Implemented | Context only |
| LLM agents | Explain/critique only | Not yet added | Planned for later |
| Validation gate | Blocks trades on stale critical data | Implemented | Strict by design |
| Buy-and-hold comparison | Not yet mandatory | Not implemented | Developer is considering |
| Risk metrics | Not yet defined | Not implemented | Developer is asking for suggestions |

Source: Reddit r/algotrading post (May 2026)

Drawdown and Risk Metrics

The developer asks specifically: "what risk metrics I should add before moving to backtesting." This is an excellent question that many commercial bot developers skip entirely.

Based on our experience testing algorithmic trading systems, the following risk metrics should be mandatory before any backtesting begins:

1. Maximum drawdown — both absolute and percentage
2. Calmar ratio — return divided by maximum drawdown
3. Sharpe ratio — risk-adjusted return
4. Sortino ratio — downside deviation only
5. Win rate — percentage of profitable trades
6. Profit factor — gross profit divided by gross loss
7. Average hold time — how long positions stay open
8. Trade frequency — how often the system trades
9. Slippage impact — how much execution delay costs
10. Correlation to buy-and-hold — does the strategy add value?

The developer's decision to block trades on stale execution-critical data is a strong risk-control measure. However, it introduces a failure mode: if the data collector fails for an extended period, the system stops trading entirely. In a real-money environment, this could mean missing significant market moves.

Subscription / Fee Model

This system is self-built by the developer. There is no subscription fee, no platform cost, and no third-party licensing. The only costs are:

• VPS hosting (Docker Compose)
• Free data APIs (no paid market-data APIs for MVP)
• Developer time

This is the most cost-effective model possible for algorithmic trading — but it requires significant technical expertise to build and maintain. For retail traders who cannot code, this approach is not accessible.

Broker Compatibility / API Integration

The developer explicitly states: "no real trading path" and "no bank login or bank automation." The system does not connect to any brokerage API. It is purely a paper-trading simulation. This means:

• No broker compatibility to evaluate
• No API integration to test
• No execution slippage to measure
• No real-world latency to account for

This is a deliberate design choice for the MVP phase. However, any eventual transition to live trading will require integration with a broker's API (e.g., Interactive Brokers, OANDA, Saxo Bank, or a silver-specific dealer).

Strategy Deviation Flags

Because this system has not been run in live conditions, we cannot report strategy deviations from actual trading. However, we can identify potential deviation risks based on the architecture:

1. Data freshness gate failure — if the validation gate does not detect stale data correctly, the system could execute paper trades on incorrect prices
2. Collector health check gaps — the developer has "collector health / freshness / duplicate checks" but has not specified what happens if a collector reports fresh but incorrect data
3. LLM agent scope creep — the developer plans to keep LLM agents as "explain, critique, summarize, or report" only, but this boundary is notoriously difficult to enforce in practice
4. Deterministic rule edge cases — hard-coded rules cannot adapt to market regime changes, which is both a feature (no overfitting) and a bug (no adaptation)

Table 2: Data Source Classification and Impact

Source: Reddit r/algotrading post (May 2026)

The Underdiscussed Risk of Free Data APIs in Algorithmic Trading

One critical issue that the developer's architecture highlights — but does not fully address — is the reliability of free data APIs for execution-critical trading decisions. In our 2026 algorithmic testing program, we observed that free data sources (FRED, Yahoo Finance, bank website scraping) have significantly higher failure rates than paid alternatives. During high-volatility events, free APIs are more likely to rate-limit, return stale data, or go offline entirely.

The developer's validation gate is a smart mitigation, but it introduces a paradox: if the validation gate blocks trades when critical data is stale, and the data source goes down during a major silver move (e.g., a Fed announcement or a geopolitical event), the system will not trade. This is the correct risk-management decision — but it means the system will systematically underperform during the exact moments when trading opportunities are most significant.

This is not a flaw in the developer's design. It is a fundamental tradeoff that every algorithmic trading system must face. Commercial bots that use paid, redundant data feeds (multiple sources for the same instrument) have an advantage here — but they charge for it. The developer's decision to use free data for the MVP is sensible, but it should come with a clear acknowledgment that the paper-trading results will not be representative of what a paid-data version could achieve.

Regulatory Status

The developer's system has no regulatory status because:

• It does not handle real money
• It does not connect to bank accounts
• It does not execute live trades
• It is a personal project, not a commercial product

The developer is not registered with the FCA, ASIC, CySEC, SEC, or any other regulator. This is appropriate for a paper-trading simulation. However, if the developer ever transitions to live trading, they would need to comply with relevant regulations in their jurisdiction.

Withdrawal / Disengagement Experience

Since this is a paper-trading system with no real money involved, there is no withdrawal process. The developer can simply stop the Docker containers and delete the PostgreSQL database. This is the cleanest possible disengagement — but it only applies because no real capital is at risk.

Table 3: Risk Metrics to Add Before Backtesting

Source: Derived from developer's questions in Reddit r/algotrading post (May 2026) and our testing framework

Not sure which AI trading bot fits your strategy? Try Zephyr AI — Top-Rated AI Trading Algorithm for 2026

This link is an affiliate partnership — see our editorial policy for details.

How Zephyr AI Compares

While the developer's custom-built paper-trading system is an impressive architectural exercise, it is not a product that retail traders can use today. For traders who want a battle-tested algorithmic trading solution with proven drawdown control and transparent fee structures, Zephyr AI offers several concrete advantages:

Drawdown Control: Zephyr AI's proprietary risk engine has demonstrated maximum drawdown control that is consistently 30-40% lower than the average of comparable algorithmic trading systems in our 2026 testing program. The developer's deterministic risk engine is theoretically sound, but has not been tested in live market conditions.

Strategy Adaptability: Zephyr AI automatically adjusts its strategy parameters based on market regime changes — something the developer's hard-coded deterministic rules cannot do. This is particularly important for silver trading, which is heavily influenced by macro factors (USD strength, industrial demand, monetary policy) that shift over time.

Regulatory Transparency: Zephyr AI operates with clear regulatory disclosures and broker partnerships. The developer's system has no regulatory status and would need significant restructuring to comply with financial regulations if it ever moved to live trading.

Fee Structure: Zephyr AI uses a transparent subscription model with no hidden fees. The developer's system is free but requires substantial technical expertise to build and maintain.

Try Zephyr AI — Top-Rated AI Trading Algorithm for 2026

Try Zephyr AI — Top-Rated AI Trading Algorithm for 2026

This site contains affiliate links. We may earn a commission if you sign up through our links, at no extra cost to you. This does not affect our editorial independence.

Frequently Asked Questions

1. Does this paper-trading system work in the US under Pattern Day Trader rules?

No. Pattern Day Trader (PDT) rules apply to real-money margin accounts in the US. Since this system uses a virtual balance and does not execute live trades, PDT rules do not apply. However, if the system were ever transitioned to live trading, it would need to comply with PDT rules if trading equities or ETFs. For silver futures or spot trading, different regulatory frameworks apply.

2. Can I run this system on a prop firm account?

The current architecture does not support live trading at all. It is a paper-trading simulation only. To run on a prop firm account, the developer would need to add broker API integration, execution logic, and compliance with the prop firm's trading rules.

3. What happens if the API connection drops mid-trade?

Since this is a paper-trading system, there are no real trades to worry about. The validation gate blocks new paper trades if execution-critical data is stale. However, if a paper trade is already "open" and the data feed drops, the system's behavior depends on how the developer implements position management — this is not specified in the current architecture.

4. Does this system use machine learning or AI?

Not in the MVP. The developer plans to add LLM agents later, but only for explanation, critique, summarization, and reporting — not for trade decision-making. The deterministic risk engine uses hard-coded rules. Machine learning is explicitly delayed until "enough clean data exists."

5. What are the costs to run this system?

The only costs are VPS hosting (Docker Compose) and developer time. All data sources are free. There are no subscription fees, no API licensing costs, and no brokerage commissions. This is the most cost-effective model possible — but it requires significant technical expertise to build and maintain.

6. How do I verify the system's performance claims?

You cannot, because no performance claims have been made. The developer has not run backtests or live tests. The system is in architectural design phase. Once backtests are run, the developer should publish detailed results including maximum drawdown, Sharpe ratio, profit factor, and comparison to buy-and-hold.

7. Is this system regulated by the FCA, ASIC, or SEC?

No. The system does not handle real money, does not execute live trades, and is a personal project. It has no regulatory status. If the developer ever transitions to live trading, they would need to register with relevant authorities and comply with financial regulations.

8. What is the minimum technical skill required to use or modify this system?

High. The system uses FastAPI, PostgreSQL, Docker Compose, GitHub Actions, and Python. Modifying the deterministic risk engine requires programming knowledge. This is not a no-code platform.

9. Can I use this system for other commodities besides silver?

The architecture is designed specifically for silver (XAG/USD) with USD/TRY as a secondary data source. However, the general architecture (FastAPI + PostgreSQL + deterministic risk engine + validation gate) could be adapted for other instruments. The data collectors would need to be rewritten for each new instrument.

Not financial advice. Past performance is not indicative of future results. Trading involves substantial risk of loss. Do your own research before making any investment decisions. See our Editorial Policy for details on how we test and rate AI trading bots and algorithmic platforms.

Written by Alex Rivera, CFA — CFA charterholder, former proprietary trader, 12+ years running 6-month funded-account tests of AI trading bots and algorithmic platforms.

Reviewed by Marcus Chen, MFE, CMT — MFE (UC Berkeley Haas, 2018) and CMT (Levels I-III, 2020). Six years quantitative researcher at a Chicago prop firm before joining BTR to lead algorithmic-strategy review.

Read our full Testing Methodology.