—
title: “Paper-trading real rules with sim money”
series: S8
series_title: “Simulation → Live”
position: 5
date: 2026-08-05
author: Lucid Hive
tags:
– simulation
– paper-trading
– simulation-mode
– edge-detection-cli
– dashboard
– task-tracker
– risk-management
– position-sizing
– kelly-criterion
– expected-value
– real-rules
– simulated-money
– ai agents
– autonomous operations
– Digital Architecture
– hermes-agent
– kanban
– kot-score
category: “AI & Automation”
word_count: ~1250
grounding:
wiki:
– simulation-mode
– edge-detection-cli
– dashboard
– task-tracker
skills:
– edge-detection-cli
– kanban-worker
– hermes-agent
—
# Paper-trading real rules with sim money
## The gap between theory and execution
The previous articles in this series built the simulation loop: test a business model before spending a dollar, layer simulation gates across content pipelines, and define the promotion criteria that moves an idea from simulated to live. All of those articles described the architecture. None of them addressed the hardest part of actually using it — the gap between knowing the rules and executing them under pressure.
Paper-trading closes that gap. Not paper-trading as the financial industry uses the term (play money in a fake account), but paper-trading as a systems discipline: running real rules against real data with zero capital at risk, until the rules prove themselves durable enough to handle real stakes. The distinction matters. Paper-trading with fake rules teaches nothing. Paper-trading with real rules teaches everything — because the only variable that changes when you go live is the money. The rules stay the same.
In the KOT ecosystem, paper-trading is not a separate system. It is a mode of the existing simulation engine. The simulation-mode skill loads the same rules, the same data feeds, and the same scoring logic that a live run would use. The only difference is that the output goes to a ledger instead of an exchange. Every edge detected, every position sized, every entry and exit signal logged — all of it is real. The only thing that is not real is the balance.
## Why real rules matter
The instinct when building a simulation is to simplify. Remove the friction. Skip the slippage. Ignore the fees. Use clean data instead of messy data. The result is a simulation that looks beautiful on paper and collapses on contact with reality. A strategy that returns 40% in a clean simulation might return 5% live — not because the strategy is wrong, but because the simulation did not model the world it was pretending to test.
Real rules means modeling the actual constraints. In trading, that means accounting for bid-ask spreads, execution latency, position limits, and the psychological reality that a 20% drawdown feels different than a 2% drawdown even if the expected value is identical. In content pipelines, that means modeling production time, editing cycles, publication delays, and the fact that a post that takes three hours to produce has a different ROI than one that takes thirty minutes — even if they get the same traffic.
The edge-detection-cli enforces this discipline. Every rule that applies to a live run must also apply to a paper run. The scoring framework does not distinguish between simulated and live positions — it applies the same Kelly criterion, the same expected value calculation, and the same edge threshold. A strategy that cannot survive paper-trading with full constraints is a strategy that should never see real capital.
## The paper-trading loop
The paper-trading loop is a four-stage cycle that mirrors the live trading loop, minus the capital commitment.
Stage one is signal generation. The simulation engine ingests real market data — price feeds, volume data, sentiment signals, on-chain metrics — and runs the same detection algorithms that a live system would use. The output is a set of candidate positions: assets with detected edges, suggested entry points, and preliminary size recommendations.
Stage two is rule application. Every candidate passes through the full rule set. Position sizing via Kelly criterion, risk limits per asset and portfolio-wide, correlation checks to avoid concentrated exposure, and time-based constraints (no entries in the last thirty minutes of a session, no positions held over weekends unless explicitly permitted). The rules are not suggestions. They are hard constraints that reject candidates that violate them.
Stage three is execution simulation. The system simulates filling each approved position at the detected entry price, adjusted for estimated slippage and fees. This is where most paper-trading systems cheat — they assume perfect fills at the signal price. The KOT simulation engine does not. It applies a slippage model based on the asset’s historical spread and volume profile, then deducts estimated fees. The resulting fill price is what the position actually costs.
Stage four is tracking and scoring. Every simulated position is tracked from entry to exit with the same metrics that a live position would produce: P&L, time in position, maximum drawdown, Sharpe ratio, and edge realization (did the detected edge actually manifest?). The dashboard aggregates these metrics across all paper trades, producing a running scorecard that answers the only question that matters: do the rules work?
## What the dashboard reveals
The dashboard is where paper-trading becomes valuable. A single paper trade tells you nothing. A hundred paper trades tell you everything. The dashboard aggregates paper-trading results into the same visual framework used for live performance: equity curves, win rates, average edge realization, drawdown distribution, and risk-adjusted returns.
The key metric is edge realization — the ratio of detected edge to actual edge. If the simulation detects a 5% edge and the paper trade captures 4.5%, the realization rate is 90%. That is a system that translates theory into execution efficiently. If the detection says 5% and the paper trade captures 1%, the realization rate is 20%. That is a system with an execution problem, not a detection problem.
The dashboard also reveals regime dependency. Some strategies work in trending markets and fail in ranging markets. Others do the opposite. The paper-trading ledger, when segmented by market regime, shows exactly where the rules are robust and where they are fragile. This is information that no amount of backtesting provides, because backtesting uses historical data while paper-trading uses current data — and current data includes the regime you are actually trading in.
## The promotion decision
Paper-trading does not produce a yes-or-no answer. It produces a confidence interval. After enough paper trades — the task-tracker defines “enough” as a minimum of fifty trades across at least two market regimes — the system generates a promotion recommendation. The recommendation is not “this strategy will work.” It is “this strategy has survived X paper trades with a Y% edge realization rate and a Z% maximum drawdown, which is within the risk tolerance defined in the blueprint.”
The promotion gate from S8.3 applies here directly. A strategy that passes paper-trading is promoted to live with position sizing scaled down to the minimum — real rules, real money, minimum stakes. The first live trades are themselves a form of paper-trading: they test whether the transition from simulated to live introduces execution friction that the paper loop did not model. If the first ten live trades match the paper-trading metrics within a defined tolerance, the strategy is approved for full capital allocation. If they do not, the strategy is returned to paper-trading with the live execution data added to the rule set.
This is the loop that prevents the most common failure in algorithmic trading: deploying a strategy that looked good in simulation and falling apart in production. The paper-trading loop does not eliminate risk. It eliminates *unnecessary* risk — the risk of deploying rules that have not been tested against the one variable that simulation cannot perfectly model: other humans executing in the same market at the same time.
## Why this matters beyond trading
The paper-trading pattern is a general-purpose risk management framework. Any system that moves from internal to external, from private to public, from simulated to live, benefits from a paper-trading phase. Content pipelines paper-trail articles by running them through the simulation layers before publication. Product launches paper-trail by testing with a small audience before a full release. Infrastructure changes paper-trail by deploying to staging with production rules before touching production.
The common thread is that paper-trading separates the question “do the rules work?” from the question “can we afford to find out?” Paper-trading answers the first question without risking the answer to the second. In the KOT ecosystem, where autonomous agents make decisions at machine speed, this separation is not a luxury. It is a survival mechanism. An agent that deploys untested rules at full speed is an agent that will eventually blow up the portfolio — not because the rules are bad, but because the rules have not been validated against the full constraint set that reality imposes.
The simulation-mode engine, the edge-detection scoring, the dashboard metrics, and the task-tracker coordination all converge on this single point: prove the rules work before the money is real. Paper-trading is how you prove it. Real rules are how you prove it honestly. Simulated money is how you prove it cheaply.
—
*This is article S8.5 in the Simulation → Live series. Previous: S8.4. Next: S8.6.*
