Historical paper-trading case studies
These three cases expand the event table into readable accounts of the starting state, recorded requests, returned results and subsequent reconciliation. They are selected July 2026 production-runner records with simulated paper execution. They do not describe the current alpha, real-capital outcomes or a representative sample of failure rates.
The descriptions below are editorial summaries of the records, not quotations of a model's reasoning. data/tool_excerpts.jsonl contains 18 sanitized request/response projections; data/case_start_states.jsonl contains the five selected starting contexts. The 29-row workflow_events table remains the compact chronological index. Values replaced by aliases or withheld markers are not original wire payloads.
Case 1: opening succeeds while memory persistence initially fails
Starting state and scope
The selected account has no open positions in its recorded starting snapshot. This case includes one opening order, two trigger requests, two memory-write requests, a finalization request and the turn's backend completion. It ends at that turn's completion; it contains no closing trade or later performance history.
The operational sequence is an opening followed by protective-trigger setup and a record of the position in persistent memory. The strategy that selected the asset, side and size is withheld. The excerpt therefore lets a reader examine execution reporting and memory recovery, but not judge the entry decision.
Recorded sequence
| Event | Recorded action | Returned result or reconciliation | What the record establishes |
|---|---|---|---|
| 1 | Submit an opening order | A successful terminal order receipt with a fill reference | The reference also occurs in the archived paper-fill reconciliation; it is a simulated fill |
| 2 | Create the first protective trigger | Active trigger with resolved association fields | A trigger was created; this is not evidence that it later fired |
| 3 | Create the second protective trigger | Active trigger with resolved association fields | A second trigger was created; it is distinct from the first |
| 4 | Write position-related memory | Transport success, application error, retryable=true |
The call must be counted as a failed memory operation despite the transport status |
| 5 | Submit another memory write | A successful result reporting last_operation=append |
The second request's body is shorter than the first; the body contents and capacity values are withheld |
| 6 | Request finalization | A terminal model call is issued | This alone does not establish that the backend completed the turn |
| 7 | Reconcile backend state | The turn record is completed after the included tool calls | Backend completion is separately supported |
Recovery and state distinctions
The memory failure occurs after the order and trigger operations have succeeded. It must not be rewritten as a failed trade, a canceled opening, or a reason to submit the opening order again. Only one opening call appears in this complete selected parent attempt.
The source contains a memory-capacity error followed by a shorter request and a successful update. This is evidence of the observed recovery sequence. It is not a controlled experiment establishing how much shortening is necessary, whether shortening is the only cause of success, or what the correct memory policy should be. One materialized memory revision is reported across the two requests; counting both requests as durable writes would overstate the result.
The trigger association also needs careful reading. The requests specify position-kind, asset and side fields without an explicit account field. The successful responses include a resolved account association. They do not include an immutable position identifier in that binding. The projections retain this distinction with release-local aliases.
Useful checks and limits
An evidence consumer should detect the application error, count one included opening order, and require the backend completion record before claiming the turn completed. A later benchmark could test whether a system responds to memory failure without duplicating an already-executed action. This excerpt supplies an observed case and proposed evidence-reading questions; it does not validate a model's ability to solve that task.
No later exit, funding, slippage, return, or causal claim about memory quality is supported by this case.
Case 2: a turn continues after incomplete trigger setup
Starting state and scope
The first attempt starts from an account snapshot with no open positions. The retry starts from a new recorded context containing one open position. Both attempts belong to the same backend turn. They are not two independent trades or two independent examples of successful opening.
The source describes the first successful trigger as a stop and the failed requests as attempts to establish the associated target. The exact levels, instructions, trade side and monetary values are withheld. The record supports saying that one protective trigger existed while another requested component failed; it does not support saying that every requested protection was already in place.
Recorded sequence
| Event | Attempt | Recorded action or state | Result |
|---|---|---|---|
| 1 | 1 | Submit an opening order | Simulated fill reconciled to the archived ledger |
| 2 | 1 | Create the stop trigger | Active trigger returned |
| 3 | 1 | Request the target trigger | Application authorization-context error; retryable=false |
| 4 | 1 | Make another target-trigger request | Another authorization-context error; retryable=false |
| 5 | 1 | Write lifecycle memory | Successful memory result reporting an append |
| 6 | 1 | Request finalization | Terminal model call issued |
| 7 | 1 | Reconcile backend completion | No completion record for this attempt; completion is deferred |
| 8 | 2 | Create the missing target trigger | Active trigger returned under the new context |
| 9 | 2 | Update lifecycle memory | Successful result reporting a compact operation |
| 10 | 2 | Request finalization | Terminal model call issued |
| 11 | 2 | Reconcile backend completion | The backend turn is completed after attempt 2 |
What changed, and what remains unknown
The retry context is a different snapshot for the same backend turn and already contains the opened position. There is no opening-order call in the second attempt. Its successful trigger request must not be counted as a second position opening.
The two failed calls returned retryable=false. The observed extra request is preserved as behavior to examine, not an endorsed retry policy. The later successful attempt also has a fresh context. The excerpt does not isolate why authorization failed, establish a security defect, prove that a particular argument omission caused it, or show that repeating a non-retryable call is generally safe.
Completion is stored at backend-turn level, with no attempt identifier in the completion row. The source review checks the turn identity, recorded attempt count and completion timing. It does not fabricate a direct attempt-ID match. The distinction between a terminal model call and backend completion is central to this case.
Useful checks and limits
The included questions test whether a reader recognizes both failed trigger results, preserves their non-retryable flags, avoids double-counting the opening, and postpones the completion claim until the final backend record. A future sequential benchmark could examine recovery with an already-open position and incomplete intended trigger coverage. This package does not run that benchmark or measure the best recovery strategy.
The case does not disclose the participant's instructions, the missing target's level, the duration of exposure, or any financial consequence.
Case 3: research, an opening, and a linked trigger-driven close
Starting state and included contexts
The opening context has no open positions in the selected account. The later closing context contains one open position. This case includes those two selected parent turns and a small view of the research child called during the opening turn. Intervening turns, elapsed time and the continuous price/position path remain outside the release.
The research request names ten assets, requests technical analysis and supplies timeframes. The public projection replaces their names with local aliases and withholds the query, horizon and timeframe values. asset-A denotes the eventual order's asset within this case; it has no relationship to the same alias in another case.
Recorded sequence
| Event | Segment | Recorded action or state | Result |
|---|---|---|---|
| 1 | Opening | Invoke market research | A research response is returned to the parent |
| 2 | Opening | Submit an opening order | Paper fill receipt appears in the archived fill reconciliation |
| 3 | Opening | Create an invalidation trigger | Active trigger returned with resolved account/asset/side association |
| 4 | Opening | Write lifecycle memory | Successful append result |
| 5–6 | Opening | Request finalization, then reconcile completion | The opening turn completes |
| 7 | Closing | Observe the linked trigger firing | The private archive identifies it as the closing turn's initiator |
| 8 | Closing | Submit a full close | A closing paper fill is reconciled to the same position |
| 9 | Closing | Request lifecycle-memory deletion | The memory service reports a compact operation |
| 10–11 | Closing | Request finalization, then reconcile completion | The closing turn completes |
The research child
The source archive contains two child-tool calls: technical analysis and news signals. The child-event file identifies these categories and the presence of their result records. Its row order is presentation order; it is not a timing trace or proof that the calls ran serially.
The archived child-final-content and parent-tool-result receipts match, and their retained content strings were compared directly during packaging. This supports the claim that the parent's research response corresponds to the child result. It does not independently validate the analysis, prove coverage of all ten requested assets, establish information freshness, or show that the research improved the subsequent decision. None of the news text, market series or model reasoning is included.
How the position relationship is established
Matching asset names alone would be insufficient. The private source review joins the opening fill, the created trigger, the event initiator, the closing fill and the archived position relationship. case_linkage.json exposes consistent local reference aliases for the two fills and the trigger while keeping the original identities private.
The terminal position snapshot is recorded as closed with zero size. The triggering record's terminal status is disabled. These are separate observations; they do not imply that every possible trigger, position, or account outside this selected relationship has been cleaned up.
The trigger's returned binding is account/asset/side based. The same-position link is established through the private archived reconciliation, not by pretending that the trigger response contained an immutable position identifier. A reader should keep those two sources of identity evidence separate.
Useful checks and limits
The questions test whether a reader distinguishes returned research from correct research, recognizes the linked event and full close, and avoids treating two endpoints as the whole trajectory. The data could inform future tests of parent/child handoff, trigger association, execution reconciliation and memory cleanup.
The excerpt cannot reproduce the strategy, reconstruct missed opportunities, evaluate exit timing, or estimate returns. It does not establish that the research caused the opening decision or that the trigger policy was economically optimal.
Using the scenario questions
data/scenario_questions.csv contains nine proposed questions with answer keys and event references. These are source-grounded evidence-reading exercises, not a validated model leaderboard or a completed training benchmark. They can be used to check a parser or explanation against the packaged record. Using them as a model evaluation requires a separate protocol, scoring rules, held-out cases and leakage controls.
Reading projections correctly
request_projection and response_projection preserve only approved structural and outcome fields. They combine a small number of retained source values with explicit withheld markers, local aliases and labelled reconciliation facts. They are not original API payloads and must not be submitted to a trading system. Original field names appear in limited cases to make distinctions such as retryable, last_operation and terminal inspectable.
An order result's terminal=true is retained from that receipt and is not treated as proof that the agent's backend turn completed. The separate backend record is required for the latter claim.
The richer presentation adds detail to the same selected historical records. It does not add participant identities, exact trade timestamps, original assets, financial values, strategy text, prompts, reasoning, raw reports, private endpoints or model-serving configuration. The source map remains outside the public archive.