Learning a Hidden Cost Structure from Outcomes Alone

Wakeline GmbH · Research report · August 28, 2026

Abstract

We report three pre-registered experiments on a continuous learning system placed in a simulated equities environment. The system receives a stream of numbers per register and can press one of three buttons (buy, sell, hold) and receives the resulting change in value. It is given no description of the domain: no rules, no vocabulary, and no statement of what a good outcome would be beyond a preference for larger ones. Unknown to it, the environment withholds 25% of any realized gain, which is what a capital-gains tax does.

Within its first simulated year - and for the remaining twenty-five - the system all but stopped selling registers carrying large unrealized gains. Inspection of its learned values shows that behind this behavior sits a reconstruction of the tax schedule, calibrated to within about 6% of what the environment charged at every bounded level of gain. Experiment 1 establishes causation. With the tax removed the behavior never forms, and across four separate runs at four different fixed rates its strength scales approximately in proportion to the rate. Experiment 2 removes the system's ability to observe the outcomes of actions it did not take, and finds the schedule is recovered at parity regardless. Experiment 3 runs a Q-learning baseline on the same representation and finds that it also recovers the schedule, but with a factor of 8 to 15 variation across random seeds and stored values at individual situations that are wrong by factors of four to six.

We report two failed predictions from Experiment 1, one from Experiment 2 and two from Experiment 3, and a fourfold discrepancy between two of our own measurements which we trace to a specific property of one of them. All results are internal and have not been independently replicated. No performance figures are reported.

1. Introduction

Operational environments contain structural frictions that are rarely written down: taxes, equipment degradation, switching penalties, contractual costs. A system that must be told every rule inherits every omission its designers made. A system that infers rules from the consequences of its own actions can, in principle, find the ones they forgot, and if its learned representation is legible, it can report what it found.

Our Continuous Learning System (CLS) has previously been described in one role, forecasting day-ahead electricity prices, where it maintains a running model of a stream. This report concerns its second capability, acting and learning what actions cost. The two are not the same problem. A perception layer succeeds by staying aligned with what the environment does, and needs no notion of what would be desirable. An executive layer cannot function without one, because a system that acts must be able to tell a better outcome from a worse one. Section 2 states what we supply for that purpose, which is one ordering and nothing else. The system contains no gradient descent, no weights and no pretraining; it accumulates experience of what each action produced in each kind of situation, in a form that can be read directly.

The question this report addresses is narrow and testable. Given an environment containing a cost structure the system is never told about, does it recover that structure, and can we demonstrate that the structure and not something correlated with it is the cause?

2. Experimental setup

Environment. 267 registers carrying daily US equity price series from 2000 to 2026, 6,791 decision steps per run. At each step the system may buy, sell or hold on each register. The outcome returned is the resulting change in value, net of transaction cost and net of a flat 25% tax applied to any realized gain. Transaction costs and slippage are applied identically in all conditions; only the tax rate varies between experimental arms.

What the system observes when deciding. A small set of scalar quantities per register, derived from that register's recent price history and from the perception layer's forecast for it, together with a flag indicating whether a position is currently open. Among them is the register's unrealized gain relative to its cost basis, which is the coordinate every result in this report is indexed by. No field encodes the tax rate, the tax paid, or the after-tax value of any action, and no field is derived from any of those. The system has no representation of "stock", "market", "money" or "tax"; those words appear in this report for the reader's benefit only.

Perception without reward, action with a preference. We have argued elsewhere (Why Weights Are the Wrong Place to Store Experience) that a predefined reward signal is the wrong thing to learn from: it is a scalar someone specifies in advance to say whether an outcome was good, and it presumes the designer already knows what good looks like in an environment the system has not yet met. That argument is about perception, and it is unqualified there. A perception layer's only job is to stay aligned with what the environment actually does. Attaching a designer's notion of desirability to that would corrupt the one thing it exists to get right, and the signal it needs is already available for free: whether what it expected is what happened.

An executive layer is a different case, and the distinction is easy to lose. A system that acts must have some way to distinguish a better outcome from a worse one, or nothing follows from anything it has learned. This is not a compromise of the argument above; it is what separates the two layers. The relevant biological comparison is not a reward function but a drive: an organism low on glucose is not told that a particular berry at a particular hour is worth eating, it is equipped with a primitive signal tied to its own state, and everything specific about where food is and what obtaining it costs has to be learned.

What we supply here is of that kind, and it is a single sentence long: among the actions available in a situation, prefer the one whose recorded outcomes have been larger. That ordering is over a quantity the environment measures directly. It contains no description of the domain, nothing about what a good trade looks like, which situations deserve attention, or what to trade off against what. It contains no tax. Preferring larger outcomes does not tell a system that selling a register which has risen costs a quarter of the gain, that the cost grows with the gain, or that this is worth changing its behavior over. Everything in that sentence had to come from experience, and it is the subject of this report.

Prediction fidelity remains the signal that drives adaptation on the action side too. What the system holds about each action in each situation is a prediction of what that action yields, and experience corrects it. The environment supplies the correction automatically, as expectations borne out or not, and no designer has to anticipate what a good outcome would have been.

Two further properties of that essay's argument are visible in this report, not merely assumed. Storage is separate from the mechanism that evaluates it, which is why Section 4 can quote what the system learned instead of inferring it from behavior. And the store is updated within the interaction, not across a training cycle, which is what allows a 26-year run with no training phase in it.

Where the tax is. It is applied in two places, both after a decision has been made. First in the environment's cash accounting when a sale executes:

gross_profit = (sell_price - original_buy_price) * num_shares
transaction_costs = (sell_price * num_shares * self.transaction_cost)
net_profit = gross_profit - transaction_costs
tax = max(net_profit * self.tax_rate, 0)
net_profit_after_tax = net_profit - tax
money_after_sale = (sell_price * num_shares) - transaction_costs - tax

Second in the outcome message reporting what a step actually cost:

exit_cost_pct = 0.0
if held_before:
    basis = pre_basis.get(ticker, 0.0)
    gain_pct = (float(prev_close) / basis - 1.0) * 100.0 \
        if self._valid_price(basis) else 0.0
    exit_cost_pct = self.tc_pct + self.tax_rate * max(gain_pct - self.tc_pct, 0.0)

tax_rate appears in exactly these two places in the execution path. The precise claim this report makes is therefore not that the system is given nothing about the tax, which the second snippet would contradict, but that nothing about the tax appears in what the system observes when deciding; the tax reaches it only as the realized consequence of an action already taken. That is what an outcome signal is for. In Experiment 2 the claim narrows further, to the consequence of the action actually executed.

What is measured. The central quantity throughout is the sell-slope: how much more the system expects selling to cost per unit of unrealized gain. Formally, the slope of its learned value of selling regressed across levels of unrealized gain. This quantity has a known true value: because the environment withholds 25% of a realized gain, selling something that has risen one unit further costs 0.25 units more. The true sell-slope is therefore +0.25, and it is the tax rate. Where figures report values relative to a reference, the reference is the 25% arm.

Values are read at two levels, which we distinguish throughout because they are not interchangeable. The situation level is what the system has stored about one specific kind of situation. The whole-readout level is the aggregate value the system acts on, in which gain-bearing components are averaged together with the many components of a situation that have nothing to do with gain. Section 6 explains why the two differ by a fixed factor.

Levels of gain. Unrealized gain is discretized into levels. All but the topmost are bounded ranges. The topmost is open: every position above a threshold falls into it, whether it has risen by a tenth or by several multiples. This distinction matters for every result in this report and is discussed in Section 7.

Reported values. Experimental conditions were run at three random seeds, and reported values are medians across those three rather than single runs. The one exception is the 10% tax arm of Experiment 1, which was run at a single seed; it is a supporting point in a dose series rather than a comparison the argument rests on, and it is marked as such where it appears.

Pre-registration. Each experiment fixed its expectations, its measurement definitions and its refutation criteria in a manifest committed before any measured run, and is graded afterwards against that manifest's literal wording. Configuration differences between arms were enforced by an automated guard that refuses to launch a run if any parameter other than the one under test differs from the reference; the guard's refusal was demonstrated against a deliberately corrupted configuration.

BOOKKEEPING_KEYS = {"run_name", "comment", "arms", "persist_store"}

def semantic_diff(cfg_a: dict, cfg_b: dict):
    keys = (set(cfg_a) | set(cfg_b)) - BOOKKEEPING_KEYS
    return sorted(k for k in keys if cfg_a.get(k) != cfg_b.get(k))

def guard(arm_cfg_path: str) -> dict:
    ...
    diff = semantic_diff(arm_cfg, ref_cfg)
    allowed = diff == ["tax_rate"]
    if not allowed:
        raise SystemExit(
            f"FATAL (confound guard): {os.path.basename(arm_cfg_path)} deviates "
            f"from the reference in {diff} — the protocol allows EXACTLY "
            f"['tax_rate']. Nothing was launched; ...")

A guard that has never fired is an untested guard, so before every measured launch it is fed configurations that should be rejected, and its refusals are recorded.

3. Observed behavior

The following was not designed. The system's starting disposition contains no holding-period preference and no asymmetry between risen and fallen registers.

Positions are FIFO-paired from the trade log, in calendar days, pooled across three seeds. Positions still open when the run ended are excluded, and there are more of them in the reference arm (358 against 97), so the figures above understate the reference arm's holding.

That risen positions out-hold fallen ones is partly mechanical, and the control shows it: appreciation takes time, so even with no tax the system's risen positions are held about 1.6 times longer than its fallen ones. What the tax adds is the widening of that against the control, roughly three to four fold at every level of gain. The size of the gap is the finding, not its existence.

An unrealized gain is untaxed; realizing it is not, so selling something that has risen converts a paper gain into a tax liability while holding defers it. It is a rule about the cost of acting, not about price movement, and it is invisible in any single outcome, since one sale simply returns slightly less than the price implies. The structure exists only across many decisions at differing levels of gain.

4. Reading the learned values

Because the system's experience is stored in a legible form, its learned value of selling can be read directly and compared against what the environment charged.

At every bounded level the system is calibrated to within about 6%, overshooting slightly and consistently; across gain codes 1 to 5 the ratio runs between 0.99 and 1.06. At the open-topped level it undershoots by 37%, for reasons given in Section 7.

The correlation between the learned and charged profiles is 0.9985. On its own that number would mislead. It is computed over six points, three of which cluster at the low end while the open-topped level carries almost all the spread; in that configuration a correlation near 1 is close to automatic. The regression slope is 0.61, driven almost entirely by the open-level undershoot. The per-level ratios above carry the information.

A systematic search for market-predictive structure behind the behavior, meaning any price-derived signal that might justify holding for reasons unrelated to tax, returned nothing.

5. Experiments

5.1 Experiment 1: the tax removed, and the tax varied between runs

Design. The full run repeated at four tax rates, 0%, 10%, 25% and 40%, with all other parameters identical and guard-enforced. Ten full-scale runs in total: all four rates at the headline seed, and the three rates that carry the argument, 0%, 25% and 40%, repeated at two further seeds. The 10% arm was run once, at the headline seed, and appears in the dose table and in Figure 3 as a single point on one of the three lines.

The rate is fixed for the whole of any given run. Each arm is a separate world with a constant rule, and a system instance encounters exactly one rate across its entire 26-year lifetime; the variation compared below is between runs, never within one. Behavior when the rule changes during a run is a different question and is not addressed here.

Result. With the tax removed the behavior does not form. The sell-slope measures between 0.0003 and 0.005 times its reference strength, at every seed, across 26 simulated years. What the system learns instead is the truth about that environment, which is that selling costs the same modest amount regardless of gain, because the only thing it costs is the transaction.

With the tax present, the behavior scales with it, approximately in proportion to the rate charged.

Note: the 10% arm was run at one seed; the other three rates were run at three seeds each. The holding column is a mean over FIFO-paired positions at the headline seed, indexed to the zero-tax arm; under a median the same column reads 1.00, 5.0, 5.3 and 5.0. The dip at 40% is a single-seed feature: pooled across three seeds the column is monotone at 1.00, 3.7, 3.9 and 4.0.

Tracked cumulatively per register, average holding separates in the first year, 53 days against 22, and ends at 346 against 73. That measure is a running average and therefore smooth by construction, so its steadiness is a property of the statistic rather than a finding. The separation itself is not: measured per position at run end, the medians are 308 days against 58.

Graded predictions. Five of seven confirmed. Two failed as written, meaning the pattern they described held in substance but not in the literal terms the frozen manifest used, and we grade against the literal terms. Both failed at the top tax rate, in regimes where the effect was already near-total. Holding duration dips 1.5% from an already fourfold plateau at one seed, and high-gain selling rises by about three decisions in over a hundred thousand. A seventh could not be tested. We expected to watch the behavior grow from nothing, but it was already present at the first scheduled measurement, one simulated year in. The obvious worry about such a result is that the behavior was built in rather than learned, and the zero-tax arm rules that out directly: the same system, with the same starting disposition, never develops the behavior at all when the tax is absent. What the measurement failure tells us is about our cadence, not about the system. Whatever the system needs in order to work out that selling a risen register is expensive, it has well inside the first year, and a yearly snapshot cannot resolve something that fast. Filming the onset requires a finer measurement interval and is the first thing the next study fixes.

5.2 Experiment 2: removing observability of unmade actions

Motivation. In this environment the system's own orders do not move prices, so the outcome an unmade sale would have produced is observable, and the system records it against selling even where it held. Most environments do not offer this. If the schedule is recoverable only under that condition, the result describes the simulator rather than the architecture.

Design. The system restricted to the consequence of the action actually taken. If it held, it learned nothing that step about selling. Three seeds plus a zero-tax control. The restriction was audited decision by decision, with zero violations. We pre-registered the prediction that the restricted system would reach less than half the fidelity of the unrestricted one.

The audit drives the learner as a black box through several hundred decision and outcome cycles with the restriction in place, and counts at each step whether more actions received a consequence than the set of executed and chosen actions permits. It reads only the learner's public step summary.

summary = C.record_outcomes(step + 1, {"X": {
    "ret_step_pct": 0.4, "exit_cost_pct": 9.5, "entry_cost_pct": 0.1,
    "buy_fill_ret_pct": None, "executed_action": executed,
    "position_open": long, "position_closed": (executed == "SELL")}})
total += summary["credited_actions"]
if summary["credited_actions"] > len({executed, chosen}):
    violations += 1

BANDIT AUDIT: 383 immediate credits over 399 steps; steps crediting more
actions than |{executed, chosen}|: 0
PASS — no unchosen, unexecuted action ever receives a consequence

Two method names, one summary key and our internal component names are renamed for publication throughout this report; no logic is altered and no other edits are made. The outcome call handles all registers for a single decision step at once, which is what its original name refers to. Learning is not batched over time: every step's outcomes are written when they arrive, and there is no accumulation phase, no replay and no training pass.

Result. The prediction failed. The restricted system recovered the schedule at ratios of 1.03, 1.05 and 1.03 against the unrestricted system across three seeds, with its zero-tax control flat at 1.3% of signal. Sampling was not marginal; between 225 and 494 actual sales were executed per gain level.

Observability is an accelerator rather than a prerequisite. What it buys is uniformity. Probed at coordinate combinations visited zero times in 26 simulated years, the unrestricted system's fidelity was indistinguishable from its fidelity at common situations (ratio 1.01); the restricted system fell to between 0.70 and 0.90, still recovering 77% to 107% of the unrestricted level at unvisited combinations.

5.3 Experiment 3: comparison with a Q-learning baseline

Method under comparison. Q-learning is a standard reinforcement learning technique that stores an estimated value for each situation-action pair and updates it toward the observed outcome plus the estimated value of the successor state. It is the closest well-understood comparator to our architecture, since both store values per situation and differ in how those values are written.

What we ran is not a textbook tabular Q-learner over raw states, and the difference matters in the baseline's favor. A flat table was built first and measured to be infeasible on this state space: 21,491 reachable states at a median of three visits each. It was rejected before the study began. The baseline used instead keys its table on the same factored representation our own system uses, with the same discretization and the same read-side conventions, importing the same functions from the same module rather than reimplementing them. The accurate description is therefore Q-learning-style value learning on the shared representation, which isolates the write rule more tightly than sharing inputs alone would.

The update, as implemented. With the discount set to zero there is no bootstrapping from a successor state, so the rule reduces to an incremental regression of each situation-action value onto its immediate observed outcome, using the same one-interval outcome record our system receives:

delta = r - Q(s, a)
N(s, a) += 1
Q(s, a) += max(1 / N(s, a), 0.02) * delta

The step size decays with visit count rather than being fixed, floored at 0.02. Values start at zero, as ours do. One number in the frozen configuration is inert and worth flagging for anyone who reads it: a constant learning rate of 0.6 is recorded, but it applies only in a mode the study did not use.

Discounting was searched, and never helped. Three discount factors were tried for both arms. For the taken-action-only arm, non-zero discounts were clearly harmful. For the other, a discount of 0.5 scored within the registered tie band of zero and lost on the pre-registered tie-break. Both arms selected zero. On this task, then, bootstrapping toward the value of the successor state bought nothing, which is a property of the task worth recording: the cost the system is learning about is realized at the moment of sale rather than propagating forward through states.

Design. Four arms: our system and the baseline, each with and without observability of unmade actions. Identical data, configuration and seeds.

What is shared, and the three things that are not. Observations and outcome records are produced once per step by the same driver code and delivered through a single dispatch path; which learner receives them is a constructor argument, so no arm can receive different plumbing. Both learners see the same coordinates, take the same three actions under the same availability and tie-breaking conventions, and share the factored representation and read-side conventions described above.

# the learner slot: absent an override, the production learner
impl = kwargs.pop('learner_impl', None)
learner_cls = default_learner if impl is None else load(impl)
self.learner = learner_cls(...)

# one decision call per step, to whichever learner holds the slot
decisions = self.learner.decide_all(step, requests)

# outcomes for that step, same path
return self.learner.record_outcomes(step, observations)

Three asymmetries remain, each registered before the runs.

Separate runs. Each arm is its own run rather than two learners stepped side by side within one simulation, so what is shared is the pipeline and the configuration, not a single realized stream. This is why every comparison below is a median across three seeds.

Exploration. The baseline explores by the standard method for its family, choosing a random action with a probability that decays over the run. Ours uses a different mechanism, scaled by how much support a situation has accumulated. We did not equalize these, because removing exploration from a Q-learner would cripple it for reasons unrelated to the crediting rule under test. No clean bound exists across two different mechanisms. Within the baseline's own family the effect is first-order: its tuning-span score moved by factors of two to eight between its two exploration schedules at a fixed step size. We report this as a confound of that order rather than a bounded one.

The innate prior. Our system starts from a hand-specified prior over the three actions. The baseline receives the same object in its request but uses it in no computation, verified at the call site, where it appears only in a logging line. The baseline therefore started colder than we did. The direction of that asymmetry is against the baseline, and it is constant along the crediting axis, so the with-and-without comparisons inside each method are unaffected.

Tuning, and its limits. Q-learning's learning rate, exploration schedule, discount factor, update mode and initialization were searched before any measured run, and the selected configuration was frozen. The search was a two-stage greedy procedure over a 15-point grid, 30 runs in total, with one run per configuration. The tuning span was the first 735 steps of the same window the measured runs use, at a seed disjoint from all of them; that overlap was registered in advance as a deliberate concession to the baseline.

We do not claim the resulting configuration is Q-learning's best, and the limitation is stronger than "the search was noisy". With a single run per configuration, the search cannot distinguish a better configuration from a luckier one at all. How large that matters is visible in the two cases where a configuration was run twice. One pair differed by a factor of 20 in recovered fidelity (0.68 against 0.03), the other by a factor of 2. Two pairs are not a variance estimate, but they are enough to establish that single-run differences at this span can be larger than the differences between the configurations being compared. This is also why the study reports three-seed medians throughout and never a single run.

Two further facts belong here rather than in an appendix. The selection criterion was revised during the search, after tuning results had been seen and completed candidates rescored, and before any measured run was launched. Because that is the kind of change that can quietly determine an outcome, we replayed both criteria over the recorded candidate scores. They select the identical configuration at both stages of the search, and since both Q-learning arms ran that configuration, every measured run reported below is invariant to which criterion was used. The two rules diverge at one point, in the stage-1 selection for the arm used in the sensitivity run described below; that arm's stage-2 search was never executed under the original criterion, so we do not reconstruct what it would have chosen.

The search was also restarted once. The decaying exploration schedule had been implemented with an absolute horizon that never engaged over the tuning span, so decay was not in fact being tested. Two affected candidates were discarded and rerun under a corrected horizon; unaffected completed candidates were reused after verification against their stored hyperparameters.

What the search therefore establishes is narrow: the effects reported below hold across the configurations tried, not that Q-learning was given its best possible settings. Two things bear on how much weight that limitation can carry. A sensitivity run using Q-learning's own per-seed tuning selection rather than the common configuration recovered more of the schedule, 0.29 against 0.22, so the shared configuration did not handicap it in the direction that would flatter us. And the differences reported below are a factor of 8 to 15 in spread across random seeds and a factor of 4 to 6 in per-situation error. We consider a hyperparameter choice capable of closing gaps of that size unlikely, and we cannot exclude it.

Result: it also recovers the schedule. On this task our architecture is not the only method that works.

Three differences emerged, all pre-registered.

Observability is an accelerator in both architectures. At a 750-step span it appeared worth a factor of five to ten. Over the full run the ratio is 1.34 against a registered criterion of 2, and final recovery is no higher. Taken-action-only feedback catches up given enough experience, in both architectures.

Reliability differs. Our arms landed within 5% to 7% of each other across seeds, with and without observability. Both Q-learning arms spanned a factor of 8 to 15, each with one collapsed seed of three, and the trajectories show these were losses of structure that had been held for thousands of steps.

Legibility differs. Read at the level each update rule optimizes, both architectures appear calibrated. Read at the level of individual situations they diverge. Our stored values sit at fidelity 0.87 to 1.12 against the true schedule at every seed under both feedback regimes, while Q-learning's individual values overshoot by factors of four to six in ways that cancel in aggregate.

True value +0.25.

6. A discrepancy between two of our own measurements

Two measurements of the same store differed by a factor of four: the per-situation profile of Section 4 implies close agreement with the true schedule, while the instrument used across Experiments 2 and 3 read about a quarter of it.

Both are correct, and they measure different things. The first reads what the system has stored about a specific kind of situation. The second reads the whole-readout value the system acts on, in which the components carrying the gain coordinate are averaged together with the many components of a situation that have nothing to do with gain, each carrying equal voice. The gain-bearing share of that total is close to a quarter, and it is a fixed property of the readout, not something that varies with what has been learned. Measured across seeds it sits between 0.242 and 0.251, and applying it to the situation-level value reproduces the whole-readout value to three decimal places.

The distinction bears on Experiment 3, because the two architectures are calibrated at different levels: ours at the individual situation, Q-learning at the aggregate its updates train. No single readout is fair to both, which is why Experiment 3 reports at both.

7. Limitations

The open-topped level. Every measurement problem in this program traces to the same design choice. Because the topmost gain level has no upper bound, the population within it changes character as the market moves: during a sustained rise it contains positions up by multiples, after a fall positions barely above the threshold. It undershoots the environment by 37%, it inflates the correlation reported in Section 4, and in Experiments 2 and 3 its own zero-tax control shows structure unrelated to tax at 79% of signal magnitude, so it is excluded there and the extremes reported as unmeasured. Closing that level is the first change we intend to make.

Scope. One domain, historical data, and one rule held constant for the whole of each run. Every result here concerns a system that meets a single fixed tax rate across its lifetime. How it behaves when the rule changes mid-run, whether it detects the change, how quickly it re-acquires, and whether a returning rule is relearned faster, is untested and is the subject of the next study.

Valuation against behavior. Experiment 2 measured what the restricted system had learned, not how often it went on to sell. How the two systems' behavior differs is not established here.

The baseline comparison. Experiment 3 rests on a configuration selected by a small single-replication search, as described in 5.3. It establishes that the reported differences hold across the configurations tried, not that the baseline was optimally configured, and a comparison against a more thoroughly tuned baseline would be a stronger test. Three asymmetries between the arms are documented in 5.3: observation streams matched in distribution rather than step for step, different exploration mechanisms, and an innate prior that only our system uses. The first is common to all arms, and the third runs against us.

Replication. All results are internal. None has been independently replicated.

Interpretation. The system re-derived the consequences of a tax schedule from experience. We make no claim that it represents taxation as a concept, that it knows what a tax is, or that it could report one. It learned what selling costs, and acted on it.

8. Conclusions

A learning system given no domain knowledge and no vocabulary, and no preference beyond favoring larger outcomes, recovered a cost structure present only in the outcomes it received, and altered its behavior accordingly. Causation is established by intervention, not inferred from correlation. Removing the structure removes the behavior, and varying the structure varies it proportionally.

The recovery does not depend on observing the outcomes of unmade actions, which was our own prior explanation for why it worked and which Experiment 2 refuted. Nor is our architecture the only one that recovers the schedule; a standard method does so too. What distinguishes ours in these experiments is that it reaches the same answer at every seed, and that the values it stores are individually accurate rather than accurate only in aggregate. That is the property that made this report possible, since every number in it was read out of the system rather than inferred from its behavior.

All results were produced internally by Wakeline GmbH and have not been independently verified. Figures are approximate and rounded. This report describes a research system evaluated on historical market data in a simulated environment. It does not describe a live trading system, and no capital was deployed. Simulated results are hypothetical, carry inherent limitations, and are not indicative of any future outcome. Nothing in this report is investment advice, an investment recommendation, an investment strategy recommendation, or a financial analysis, and nothing here constitutes an offer or invitation to buy, sell or subscribe to any financial instrument. No statement is a claim about trading performance, and no performance figures are published. Wakeline GmbH does not provide investment advice, investment brokerage, portfolio management or any other financial service requiring authorisation, and is not supervised by BaFin in any such capacity.

Appendix A: pre-registered predictions, Experiment 1

Appendix B: failed predictions, verbatim

Quoted exactly as written, and frozen before the corresponding runs were launched. Punctuation inside quotations is reproduced as recorded. The manifests, with their timestamps and version history, are available on request.

Experiment 1, P5, failed as registered:

P5 — Behavioral lock-in follows the dose. Mean holding time of WINNING positions (FIFO-paired trades, sell > buy) increases monotonically with tax across the arms.

Experiment 1, P6, failed as registered:

P6 — Realization avoidance follows the dose. The SELL share among decisions taken at high-gain states (POS_STATE ≥ 5) decreases monotonically with tax.

Both broke at the step from 25% to 40%, at noise scale.

Experiment 3, P2, failed:

P2 — Counterfactual crediting is worth an order of magnitude. Median steps-to-discovery (D-ref) over seeds is at least 5× larger for B than for C.

The measured ratio was 1.34, and the corresponding refutation criterion triggered.

Experiment 3, P7, failed:

P7 — D-true is out of reach. No arm reaches 50% of the absolute true slope on the whole-bundle readout at any seed.

The baseline with observability of unmade actions reached and held the threshold at two of three seeds. (The absolute true slope is the schedule's +0.25; the whole-bundle readout is what this report calls the whole-readout level.) One caveat: a correction inside the manifest, written before the freeze, had already conceded this prediction's premise on tuning-scale evidence. The wording was deliberately left unamended rather than revised into something it would pass, and the full-window runs then decided it, an outcome the tuning evidence alone had not guaranteed.

Experiment 2, PD1, which predicted our own system would fail under restricted feedback, also failed, in the favorable direction. We attach a caveat to this one instead of presenting it alongside the others. Its manifest was written and frozen before the runs, but unlike the three above, the version history does not independently establish the ordering; the freeze is evidenced by the manifest's own decision log. Since this is the prediction whose failure most favors us, the weaker provenance is worth stating.

Full manifests, per-run diagnostics and decision-level records are available on request.