> For the complete documentation index, see [llms.txt](https://doc.lockerprotocol.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://doc.lockerprotocol.com/hyper-agentic-trader/first-paper-day.md).

# Your first simulation day

What the daily pilot does, step by step, and where to read each step afterwards.

`lpa pilot run-now` plays one day of the **daily pilot**: it reads the market and the news at this moment, thinks once, and either builds a position on the simulation account or says why it did not.

```sh
lpa pilot run-now
```

Every step is written to disk **before** the next one starts, so a day can be read back, and an interrupted day knows where it was.

The day plays the **strategy** the charter names: `ladder-long`, the measured ladder, unless you put another in use. The steps below are a day of that one; a grid, a range or a position with a stop takes the same steps and its own plan. See [The strategies](https://doc.lockerprotocol.com/hyper-agentic-trader/strategies.md) and [How it trades](https://doc.lockerprotocol.com/hyper-agentic-trader/how-it-trades.md).

## The steps, in order

{% stepper %}
{% step %}

### The strategy of the day, when there is a choice

With a choice set (`lpa pilot strategy choice --among ladder-long,range-reversal`), the pilot picks the strategy it plays before the day begins: by a table of the regime of the leading market, or by the model in one brief call that can only name a strategy you allowed. The day then runs whole under that one.

Written to `choix.json`. Every day says its strategy afterwards (`Strategy: <name>`), and a day that chose says who chose it and why. Without a choice, the day plays the strategy in use and writes no such file.
{% endstep %}

{% step %}

### The trade already held is followed

Before anything else, the day follows each position it already holds, in case the hour that just passed missed an exit. A simulated position is followed on the hourly candles closed since the last pass, a live one on the venue's own executions. A grid or a range is walked on the five-minute candles closed since its last pass, and the service follows one every five minutes rather than every hour. This is the same work as `lpa pilot follow`, and it needs no model.
{% endstep %}

{% step %}

### The guard, without a model

Cheap checks first, so a day that cannot trade costs nothing:

* a plan already in progress: with a stop one position at a time, by steps and under a grid or a range while there is room under `concurrentPositions`,
* a position on the account this pilot did not open, which ends the day,
* a limit order left resting from the day before, which is cancelled,
* then, under a strategy that places a stop (the kinds `stop` and `range`), the **circuit breaker**: three losing trades in a row pause the pilot for 72 hours. The pause lifts on its own. By steps and under a grid nothing pauses the pilot.

Written to `garde.json`.
{% endstep %}

{% step %}

### The dossier of the day

The facts the decision will rest on, gathered and then frozen with a fingerprint, and measured against the model's context so an oversized dossier is refused rather than truncated:

* Hyperliquid's candles, the markets, the funding, the open interest,
* the fear and greed index of the day,
* the public economic calendar of the week,
* the headlines of the Federal Reserve, the ECB and CoinDesk,
* hyperkeel's market brief, when it answers,
* hyperkeel's leaderboards of the day and the week, and how the top accounts of the day's are positioned on each market of the charter, read on Hyperliquid: net long or net short, the notional of their longs that would be liquidated within 8 % under the price and of their shorts within 8 % over it, and the nearest of these clusters, in percent and in days of the market's range. A fall into the long cluster can cascade lower, a rise into the short cluster higher. The trader can ask for the same read at the moment during its deliberation (`read_crowding`), and `lpa pilot deliberate --no-crowding` deliberates without either, to compare.

**No fall of the equity stops the pilot.** Since lpa 2.4.0 there is no drawdown stop: a position may sit below its entry for weeks, and the pilot waits. The stops each strategy sets for itself stay; by steps and under a grid the room before liquidation is the bound.

Also before any model: an account too small for the first step, or for a level of a grid, ends the day as `too-small` and says the equity that would do.

Written to `lectures.json` and `dossier.json`.

{% hint style="info" %}
The calendar is read through a copy kept for an hour under `~/.lpa/pilot/cache/`, because its host refuses a second reading within minutes. When the host refuses, a copy up to a day old is served, and the dossier says so.
{% endhint %}
{% endstep %}

{% step %}

### The reader

A first voice reads the **texts** alone, with no figures and no prices, and gives a climate: what the words of the day are about. Written to `lecteur.json`.
{% endstep %}

{% step %}

### The deliberation of the trader

The trader reads the charter, the strategy's own words, the dossier, the climate and the brain's lessons, and ends on one decision: a trade or nothing (a `long` under the default charter, which opens no short), with its market, its entry and its thesis. Under a grid or a range it names the market, the side it leans and, when the measured borders are wrong, the range itself.

By steps, **one deliberation decides** (the measured reason is on [How it trades](https://doc.lockerprotocol.com/hyper-agentic-trader/how-it-trades.md)). A strategy with a stop runs three, and the second and the third only when the first proposes a trade. A strategy the code decides runs none, and the day reads *with the code's rule, no model*.

Written to `trader-1.json`, `trader-2.json` and so on, with the brain's lessons in `cerveau.json`.
{% endstep %}

{% step %}

### The vote

With several deliberations, the vote reads them together and keeps one decision. With one, the vote is that decision. Written to `vote.json`.
{% endstep %}

{% step %}

### The verdicts of the code

Now the code judges what the model proposed. Each verdict has a name, a yes or no, and its figures. All of them must pass.

| Group        | Verdicts                                                                                                   | What they check                                                                                                                                                                                                                                                                                      |
| ------------ | ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The decision | `decision`, `market`, `regime`, `figures`, `side`                                                          | the trader proposed something; the market is allowed and read in the dossier; its regime is one the strategy opens in; the prices are figures; the side is one the charter opens                                                                                                                     |
| The signal   | `breakout`, `rsi`, `funding`, `pullback`, `leaders`                                                        | the rule this strategy sets, when it sets one: past the high of so many days, an excess of the hourly RSI, a funding that pays the side being faded, an entry near the daily EMA 20, the leaderboard leaning the same way                                                                            |
| The levels   | `order`, `limit`, `trigger`, `zone`, `stop`, `gain-risk`, `events`                                         | the prices in the order of the side; an entry close enough to the price; a trigger only where a trailing stop takes one; the entry zone of the week's range; the stop in daily ATRs; the gain over the risk before costs; no high-impact release inside the window, with a calendar known far enough |
| The plan     | `position`, `ladder`, `grid`, `grid-range`, `grid-side`, `range`, `leverage`, `notional`, `orders`, `size` | room for one more position; the ladder, the grid or the range holds together; the leverage within the market's and the policy's; the day's notional under the mandate's ceiling; the orders the plan starts within the orders of the day; the size the code computed                                 |
| The money    | `costs`, `model-price`, `cost-share`, `model-share`, `net-gain-risk`                                       | the whole cost in figures; a model with a price, so its cost can be counted; the costs at most `costShare`; the model at most `modelShare` of the gain aimed at; the gain over the risk still at least `minRiskReward` after every cost                                                              |

Written to `verdicts.json`, each with the figure it was held to and the bound.

Which of them run depends on the kind of the strategy in use: the zone and the ladder belong to the steps, the stop and the gain over risk to a position with a stop, the three grid verdicts to a grid, the range's to a range. [How it trades](https://doc.lockerprotocol.com/hyper-agentic-trader/how-it-trades.md#what-the-verdicts-check) gives each one in its own line.

{% hint style="warning" %}
**The calendar can refuse a day on its own.** The public feed publishes one week, Sunday to Saturday in New York. A window that runs past the end of what is published refuses the opening, and so does a calendar that could not be read: *the calendar was not read: no opening today*.
{% endhint %}
{% endstep %}

{% step %}

### The size, the quote and the cost

The code sizes the position from the charter, never from the model's wish: the base stake, the ladder, the leverage. Then it quotes the first step on the live order book, and adds up the whole cost of the trade: the fees of both legs, the funding over the days a position is expected to wait, the slippage, and the model's own dollars amortized over the trade.

The money verdicts above are judged on those figures. A trade whose costs eat its target is refused here, after the model has already spoken.
{% endstep %}

{% step %}

### The order

The first step goes out. The other steps and the exit are written in the plan at their prices, the exit at the average price plus the target. In simulation the hourly follow fills them on the closed candles as the market comes to them. On the real account they rest on the venue, the steps as limits and the exit as a reduce-only limit. A grid writes its levels and rests its starting orders; a range rests its two entries, the first filled cancelling the other. Written to `ordre.json`, and to the plan of that market under `~/.lpa/pilot/plans/`.

The day ends with one outcome, said by name.
{% endstep %}
{% endstepper %}

## The outcome words

| Outcome           | What it means                                                                                                                                                                                  |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `opened`          | a position was built                                                                                                                                                                           |
| `no-trade`        | the trader proposed nothing. The usual answer, and a good sign                                                                                                                                 |
| `no-decision`     | the trader did not reach a decision                                                                                                                                                            |
| `refused`         | the code's verdicts refused what was proposed                                                                                                                                                  |
| `order-refused`   | the venue or the policy refused the order                                                                                                                                                      |
| `paused`          | the circuit breaker of a strategy that places a stop, or a pause you asked for                                                                                                                 |
| `key-ending`      | on the real account, the agent key ends within 24 hours: nothing new opens, what is held is still followed, and once `lpa agent renew` renews the key the schedule plays the day again         |
| `model-down`      | every call to the model failed that day: nothing new opened, what is held still followed, unless `lpa pilot model-down --code` lets the code's rule decide in its place                        |
| `stopped`         | read only on a day played by an lpa before 2.4.0: the drawdown stop, which no longer exists                                                                                                    |
| `too-small`       | the account cannot buy the venue's smallest order at the first step, or at a level of the grid                                                                                                 |
| `budget`          | the day's dollars on the model are used up                                                                                                                                                     |
| `dossier-too-big` | the dossier does not fit the model's context                                                                                                                                                   |
| `no-price`        | a price the day needs could not be read                                                                                                                                                        |
| `foreign`         | a position on the account this pilot did not open                                                                                                                                              |
| `in-progress`     | the pilot already holds what the strategy in use allows, so nothing was asked of the model: one position at a time with a stop, `concurrentPositions` by steps, under a grid and under a range |

A day still running has no outcome at all yet, and `lpa pilot day` says so rather than inventing one.

## Where the files are

```
~/.lpa/pilot/charter.json          how much, and the name of the strategy in use
~/.lpa/pilot/strategies/<name>.json  the strategies you wrote yourself
~/.lpa/pilot/days/<date_time>/     one folder per day played
    choix.json                     the strategy of the day, who chose it and why
    garde.json                     the guard
    lectures.json, dossier.json    what was read, and the dossier it froze
    lecteur.json                   the reader and its climate
    cerveau.json                   the lessons read before deciding
    trader-1.json, trader-2.json   each deliberation
    vote.json                      the decision kept
    verdicts.json                  every verdict, with the sizing, the cost and the quote
    ordre.json                     the order, and the plan it wrote
    jetons.json                    the tokens and the dollars of the day
    fin.json                       the outcome, its words, and the steps taken
    screen.json                    the universe's screen, with a charter on ["*"]
    suivi-*.json                   one line per follow, with the mark and the latent result
    bilan.json                     the balance, once the position reached its exit
~/.lpa/pilot/plans/<market>.json   what the pilot holds on that market
~/.lpa/pilot/brain/<name>/         what it learned
~/.lpa/logs/pilot.log              one line per step, one line per call to the model
```

A day played under `--variant <name>` keeps its files in a folder of that name inside the day's own, so a campaign can compare variants on the same day.

## Reading it back

```sh
lpa pilot day                      # the last day, told from its files
lpa pilot day --key 2026-10-03_0030
lpa pilot day --variant careful
lpa pilot                          # the group's commands
```

`lpa pilot day` gives the outcome, the steps, the strategy the day played and how it was chosen, the vote, each verdict with its figures, the order, and the balance once the position has closed. Without a day on disk, it lists the days played.

```
Day 2026-10-11_1209: order-refused (guard, dossier, decision, vote, verdicts, sizing, order).
the order was refused: The policy refuses this order: $210.91 is above the $100 per order.
Strategy: donchian.
```

What the pilot holds right now, market by market, is `lpa pilot plans`: each position by steps with its steps, its average and its exit, each grid with its levels and the order resting on each, a range with its session, or a trade with its entry, its stop and its target.

To see a decision on one market without playing a day, and without writing a plan or a day file:

```sh
lpa pilot deliberate --symbol BTC
```

It is the day itself, played against an exchange that reads and quotes but never opens, closes nor cancels: the decision with its reason and the condition that would change it, the entry zone read from the seven-day range with where the price sits in it, the ladder or the grid with each level, the exit and what it nets, the quote of the first order, every verdict a day passes, and what the call cost. Nothing is opened, and a market the charter or the policy does not allow is refused by name.

For the money side:

```sh
lpa journal --since 24h            # orders, refusals, fees
lpa paper status                   # the simulation account's equity and positions
lpa store tokens --since 7d        # what the model cost
```

And to watch the log as it happens:

```sh
tail -f ~/.lpa/logs/pilot.log
```

Each line carries its UTC time. A line for a call to the model gives its tokens (input, read from the cache, written to it, output), its seconds and its dollars, and says when a call read nothing from the cache. The day's sum closes the log.

## The live page

```sh
lpa live
```

The live page shows every activity of this computer as it happens: the sessions, the service, the copies, the MCP clients and the pilot, with their thinking, their tools and their orders. A click on an activity opens everything it did, in order. Each order carries its quote, the limits that judged it, and the line it wrote in the journal.

The pilot's own zone on the page lets you write to it, pause it, take it up, stop it, close what it opened, confirm an order it proposed, and change its memory. See [The live page](https://doc.lockerprotocol.com/hyper-agentic-trader/live-page.md).

## Day after day

The daily pilot only gets interesting once it has a past. Three commands build one:

* [`lpa pilot follow`](https://doc.lockerprotocol.com/hyper-agentic-trader/commands/pilot.md) every hour while a trade is held, so the exit is taken on time.
* [`lpa pilot replay`](https://doc.lockerprotocol.com/hyper-agentic-trader/replay.md) to play past days in order and let the brain learn from them.
* [`lpa pilot brain`](https://doc.lockerprotocol.com/hyper-agentic-trader/brain-and-lessons.md) to read what it has learned.

{% hint style="danger" %}
**A real day is possible, and it is your gesture.** `lpa pilot run-now --live` plays the day on the real account. It starts only with the account of this home, a key in the guardian, and a mandate in force that allows `trade`. Without one of the three it refuses by name. On the real account the steps after the first rest on Hyperliquid as limits and the exit as a reduce-only limit, each order's id kept in the plan, and so do a grid's levels and a range's two entries. Without `--live` the day plays on the simulation account. See [Go live under the mandate](https://doc.lockerprotocol.com/hyper-agentic-trader/go-live.md).
{% endhint %}
