Most trading signal services give you the same thing: an output. Buy this ticker. Sell that position. The signal arrives — sometimes with a confidence score, sometimes with a target price — and you're expected to act on it. What you don't get is the input: what data produced this signal, when was it generated, what logic connected the input to the output, and how does this trade fit the risk parameters you set.

That opacity is not an accident. It's a structural feature of how most signal services are designed, and it creates a specific category of risk that transparent trading signals are designed to eliminate.

Why Opacity Is the Default

Signal services obscure their methodology for two reasons, one legitimate and one not.

The legitimate reason: protecting intellectual property. If the signal generation logic is fully visible, it can be replicated. A signal service that publishes its exact entry conditions, lookback periods, and threshold values is publishing its source code. For services with genuine edge, that's a valid concern.

The illegitimate reason: opacity hides poor methodology. A signal service that cannot explain how it generates signals — or whose signals are produced by a process that wouldn't survive scrutiny — has a strong incentive to keep the methodology hidden. Opacity makes it impossible to distinguish a rigorous process from a random one. The performance record alone becomes the only visible claim, and performance records can be cherry-picked, curve-fitted, or simply fabricated.

The two reasons are indistinguishable from the outside, which is the core problem. An investor receiving opaque signals cannot determine whether they reflect genuine edge or manufactured appearance.

What Signal Transparency Actually Means

Transparency in trading signals does not mean publishing source code. It means documenting the signal at a level that allows the investor to evaluate whether it makes sense — and audit whether it executed as described.

A transparent signal provides:

Signal timestamp. When was this signal generated, in relation to when it was delivered and when the trade was executed? A signal generated at market open that arrives three hours later is not actionable on the terms it implies. Time-stamping is the basic requirement for evaluating signal latency and execution quality.

Input conditions. What data state produced this signal? Not necessarily the exact formula, but the category: was this a price momentum signal? A sentiment score crossing a threshold? An order flow imbalance detection? The investor should be able to understand what kind of market condition the signal is responding to, even if the precise calculation remains proprietary.

Risk parameters. What position size does this signal imply? What is the defined stop loss? What is the expected hold duration? A signal without these parameters transfers the risk management decision entirely to the investor — which may be intentional, but should be explicit.

Execution record. After the trade is executed, what actually happened? Entry price, execution time, fill quantity, exit price, exit reason (target hit, stop triggered, time exit). This is the audit trail that allows the investor to verify that the strategy executed as described and to evaluate performance on factual execution data rather than theoretical fills.

The distinction between a signal and an audit trail matters. Many services provide signals. Very few provide complete execution records that allow investors to verify that the strategy's claimed performance matches actual execution.

The Audit Log Standard

A complete audit log is the infrastructure of signal transparency. It records every input that produced every signal, every signal that produced every order, and every order's actual execution outcome.

For a systematic investor, the audit log serves three purposes.

Verification. The claimed behavior of the strategy can be checked against what actually happened. If the strategy description says "exits within three trading sessions," the audit log shows whether that's true. If the entry conditions say "only enter when RSI < 35 and volume is above 30-day average," the log shows the conditions at each entry. Discrepancies between described and actual behavior are visible.

Diagnosis. When a strategy underperforms, the audit log is where the diagnosis starts. Did signals fire at the right times? Did execution match the signal? Was slippage larger than expected? Did the risk parameters trigger correctly? Without an audit log, underperformance is opaque — it happened, but the cause is invisible.

Accountability. A strategy creator who knows their execution is being logged has a different relationship to performance claims than one operating without accountability. The audit log creates a factual record that either supports or contradicts claims. This is a meaningful structural check on motivated reasoning — both the creator's and the investor's.

The audit log standard is one of the clearest differentiators between a legitimate algorithmic trading platform and a signal service that exists to sell subscriptions rather than deliver verified edge. See the full trust framework in is algorithmic trading legitimate.

What Transparent Execution Looks Like in Practice

A transparent systematic strategy deployment, from signal to audit, looks like this:

  1. Signal generation. At a defined time, the strategy evaluates market data against its entry conditions. If conditions are met, a signal is generated with a timestamp and a record of the input state.

  2. Order submission. The signal produces an order: instrument, direction, quantity, order type, risk parameters. The order is submitted to the broker API and the order ID is recorded.

  3. Execution confirmation. The broker returns a fill confirmation: execution price, fill time, fill quantity. This is stored against the original signal and order.

  4. Position monitoring. While the position is open, the strategy continuously evaluates exit conditions and records the ongoing position state.

  5. Exit and settlement. When exit conditions are met, the closing order is submitted, filled, and recorded. The complete trade record — entry signal, entry execution, exit signal, exit execution, P&L — is written to the audit log.

Every step is logged. The investor can inspect any trade at any level of detail. The strategy's claimed behavior is checkable against the actual record.

The Oyamori Approach

Every strategy deployed through Oyamori generates a complete audit log: signal conditions, order submission, execution confirmation, and exit records. Nothing in the execution chain is opaque to the investor running the strategy.

The motivation is practical: verifiable trading strategies require verified execution. A strategy with a documented edge that executes opaquely is not meaningfully better than one with no documentation — the investor has no way to confirm the strategy is running as described or to diagnose when it isn't.

Your capital stays in your Alpaca account. Every trade it executes is recorded. Every signal that produced that trade is logged with its input conditions and timestamp. The audit record is yours — it doesn't disappear if you stop a subscription or switch strategies. Transparency is not a feature that can be withdrawn. It's the baseline.

Next: Is Algorithmic Trading Legitimate? How to Spot Real vs. Scam →