> 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/charter.md).

# The charter

What the daily pilot is held to: the charter's own figures, how much, and the strategy it names, with every default and every bound.

The charter is what the daily pilot is judged by. It no longer holds one way of trading: it keeps **how much**, for every strategy, and it **names the strategy in use**, which says where the pilot looks and how it builds and leaves a position. See [The strategies](https://doc.lockerprotocol.com/hyper-agentic-trader/strategies.md) for the second half.

You do not edit a file. One command reads it whole, and one flag changes one figure:

```sh
lpa pilot charter
lpa pilot charter --set leverage=2 --preview
lpa pilot charter --set leverage=2
```

The file is still there, and `lpa` writes it:

```
~/.lpa/pilot/charter.json
```

A home with no file plays the shipped charter and the strategy `ladder-long`, which is the charter two years of four-hour candles measured.

{% hint style="info" %}
**A figure outside its bounds is refused by name, never trimmed in silence.** The refusal says which field and which range: *The charter's leverage must be a number from 1 to 5.* The same reading judges a figure typed with `--set`, a figure of a strategy, and a figure found in a file.
{% endhint %}

{% hint style="warning" %}
**The charter never widens anything.** A setting that narrows holds at once. A setting that would widen still has to pass the [policy](https://doc.lockerprotocol.com/hyper-agentic-trader/commands/policy.md) and the [mandate](https://doc.lockerprotocol.com/hyper-agentic-trader/mandate.md), which the guardian holds. The charter cannot give the pilot more room than your wallet signed.
{% endhint %}

## What `lpa pilot charter` says

```
$ lpa pilot charter
The charter is the measured one. The smallest account it opens anything on: $120.
  markets                ["BTC","ETH"]
  riskPct                1
  minRiskReward          2
  ...
  rangeCooldownMinutes   30
The strategy in use: ladder-long, shipped (a ladder). `lpa pilot strategy list` lists the others.
```

Read alone, it gives, in this order:

* whether the charter is still **the measured one**, and, when it is not, the fields that differ by name. A shipped strategy that is not the measured one is said by its name instead: *range-reversal is not the measured charter: ladder-long is, measured over two years.*
* **the smallest account** it opens anything on: with the default ladder, the equity whose first step reaches Hyperliquid's smallest order of $10, so $120; under a grid, the equity whose level buys that order whatever the range, to the cent.
* **what a day costs with the model set**, when there is one with a price, and the equity the charter's share of the model asks for with it. A strategy decided by the code alone asks no model, so neither figure is said.
* **every figure**, the charter's own and the strategy's resolved over them, one a line, each one that differs from the shipped charter marked `(changed)`.
* **the strategy in use**: its name, whether it is shipped or yours, and its kind of method.

A program reads the same answer with `--json`: `charter` (every figure), `measured`, `changed`, `floorUsd`, `model`, `dayUsd`, `modelFloorUsd`, `strategy`, `shipped` and `kind`.

## Changing one figure

```sh
lpa pilot charter --set <field>=<value> [--preview]
```

`--set` takes one pair at a time. It says what the figure was, what it becomes, and what that does to the smallest account and to the account the model's share asks for, before and after:

```
$ lpa pilot charter --set stepAtr=0.75 --preview
Nothing was written: stepAtr would go from 0.5 to 0.75. The smallest account: $120 to $120. The charter is no longer
the one two years of candles measured: measure it again with `lpa pilot calibrate`. The strategy's figures would be
kept in your own strategy ladder-long-mine, then in use; ladder-long is unchanged.
```

`--preview` writes nothing and says the same thing. Without it the change is written, and a line goes to `~/.lpa/logs/pilot.log`.

**Where the change goes** is said in the last sentence, and it follows one rule: a figure of the charter stays in the charter, for every strategy; a figure of the strategy is never written into a shipped one.

| What you change                                                 | Where it goes                                                                                      |
| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| a figure of the charter (`leverage`, `riskPct`, `costShare`...) | the charter itself, for every strategy                                                             |
| a figure of the strategy, while a shipped one is in use         | a strategy of yours named after it (`ladder-long-mine`), then in use; the shipped one is untouched |
| a figure of the strategy, while one of yours is in use          | that strategy of yours, changed                                                                    |
| `mode`, the kind of method                                      | a strategy of yours named for the new kind (`my-grid`), then in use                                |
| a figure that brings the strategy back to a shipped one's       | that shipped strategy, then in use                                                                 |

**What `--set` refuses, by name:**

| Refusal                                                                                                                   | Why                                                                                                                                 |
| ------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `The charter has no field <name>.`                                                                                        | the hint lists every field `--set` takes                                                                                            |
| `The charter's <field> must be a number from <min> to <max>.`                                                             | the bounds of the tables below                                                                                                      |
| `gridLevels is a figure of a grid, and the strategy in use, ladder-long, is a ladder: nothing it plays reads gridLevels.` | a figure of another kind of method is not kept where no code would read it; the hint writes it into a strategy of that kind instead |
| `--set takes <field>=<value>, not <text>.`                                                                                | one pair, with its value                                                                                                            |
| `--preview goes with --set.`                                                                                              | `--preview` alone says nothing                                                                                                      |

{% hint style="info" %}
**The notes are the strategy's.** What you measured and want the trader told (`notes`, at most five lines of 400 characters, each read to the model as *Measured by the person: ...*) belongs to the strategy, with the figures it comments on: `lpa pilot strategy save --name <name> --from <name>` writes it. A charter that holds `notes`, `mode` or a figure of a signal or a method is refused by that field's name, with the command that changes it.
{% endhint %}

## The charter's own figures: how much

These hold whatever the strategy, and `lpa pilot charter --set` keeps them here.

| Field                 | Default   | Bounds                         | What it does                                                                                                                                                                                                                                                                                                                                                                                              |
| --------------------- | --------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `leverage`            | `3`       | 1 to 5                         | the leverage of every step of a ladder and of every level of a grid                                                                                                                                                                                                                                                                                                                                       |
| `liquidationMinPct`   | `100`     | 25 to 500                      | how far, in percent, the price may move against the complete ladder, or against a whole side of a grid, before any liquidation. This is what fixes the base stake and the size of a level                                                                                                                                                                                                                 |
| `riskPct`             | `1`       | 0.25 to 2                      | the equity lost if the stop is hit, fees included, for the methods that have one: a trade with a stop, and a range. The position is sized from it                                                                                                                                                                                                                                                         |
| `maxLeverage`         | `3`       | 1 to 5                         | the highest leverage those two may use                                                                                                                                                                                                                                                                                                                                                                    |
| `concurrentPositions` | `2`       | 1 to 5, whole                  | positions, grids or ranges under way at once, one per market                                                                                                                                                                                                                                                                                                                                              |
| `reinvestPct`         | `100`     | 0 to 100                       | the share of realized gains the measure's account puts back to work. A real or simulation day sizes on the account's own equity, so this field only changes `lpa pilot calibrate --account`                                                                                                                                                                                                               |
| `costShare`           | `0.25`    | 0.05 to 0.5                    | the whole cost of a trade, at most this share of the gain aimed at by steps, of the risk with a stop                                                                                                                                                                                                                                                                                                      |
| `modelShare`          | `0.1`     | 0.01 to 0.3                    | the model's cost, amortized, at most this share of the gain aimed at                                                                                                                                                                                                                                                                                                                                      |
| `apiBudgetPerDayUsd`  | `0.5`     | 0 to 50                        | dollars a UTC day on the model; past it, the day thinks no more                                                                                                                                                                                                                                                                                                                                           |
| `lossStreak`          | `3`       | 2 to 10                        | losing trades in a row that pause the pilot                                                                                                                                                                                                                                                                                                                                                               |
| `pauseHours`          | `72`      | 12 to 168                      | how long that pause lasts. It lifts on its own                                                                                                                                                                                                                                                                                                                                                            |
| `eventWindowHours`    | `12`      | 0 to 48                        | no opening within this many hours of a high-impact release                                                                                                                                                                                                                                                                                                                                                |
| `eventCurrencies`     | `["USD"]` | 1 to 10 codes of three letters | whose high-impact releases bind the rule above. The others are shown and do not bind                                                                                                                                                                                                                                                                                                                      |
| `eventSides`          | `short`   | `both` or `short`              | the sides the event rule binds. Measured on 3 October 2026 over the official schedule: longs opened near a release reached their target as often as the others, shorts stayed stuck 6 % of the time against none, so the default binds the shorts alone                                                                                                                                                   |
| `throughBps`          | `5`       | 0 to 100                       | the margin, in basis points, the price must go through a step, a level or an exit before the fill counts: in the measures of every kind (a stop's target included, its stop counting at the touch, a market order), and in the replays and the brain's judgement of a ladder, a grid and a range. 0 is a touch; 5 is the prudent rule, because a maker's order at a level is not surely filled by a touch |

The base stake is not a field: the code computes it from `leverage`, `liquidationMinPct` and the ladder's sum. With the defaults it is 2.78 % of the equity, the first step is 8.33 % of it in notional, and the complete ladder engages the equity once.

{% hint style="info" %}
**The breaker binds the methods that carry a stop.** The losing streak binds a trade with a stop and a range, whose size follows its stop. By steps and under a grid nothing pauses the pilot: the room before liquidation their levels are sized within is the bound, and the risk is yours. The event rule binds every kind. No fall of the equity stops the pilot under any kind since lpa 2.4.0: `maxDrawdownPct` is gone, `lpa pilot charter --set maxDrawdownPct=<n>` changes nothing and says so, and a charter that still holds it reads as it is, the field left out at the next write.
{% endhint %}

## The strategy's figures

The strategy in use says where and when the pilot looks and which sides it opens (its **signal**), and how a position is built and left (its **method**, by kind). Every figure is read by the same rules and the same bounds as a charter's, and is changed with `lpa pilot strategy save --set "<field>=<value> ..."`, or with `lpa pilot charter --set`, which keeps it in a strategy of yours.

### The signal

| Field                | Default                                                  | Bounds                                                                | What it does                                                                                                                                                                                                                                                                   |
| -------------------- | -------------------------------------------------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `markets`            | `["BTC", "ETH"]`                                         | 1 to 10 names, or `["*"]` alone                                       | the markets the pilot may open, within the policy's and the mandate's. `["*"]` means the whole measured universe, screened each day: see [The universe](#the-universe)                                                                                                         |
| `sides`              | `long`                                                   | `both` or `long`                                                      | the sides it may open. With `long`, a short is refused by the code before anything else is weighed, and the day's screen puts none on the table: see [Longs only](#longs-only)                                                                                                 |
| `regimes`            | `null`                                                   | a list of `StrongBull`, `WeakBull`, `Range`, `WeakBear`, `StrongBear` | the regimes of a market it opens in, as the dossier reads them on the hourly and four-hour candles. `null` opens in every regime; a market whose regime is not in the list, or was not read, is refused under the rule `regime`. `--set regimes=all` goes back to every regime |
| `longZonePct`        | `33`                                                     | 10 to 100                                                             | a long opens only in this lower share of the seven-day range; 100 is no zone. A ladder's: under 100 is refused for any other kind                                                                                                                                              |
| `shortZonePct`       | `33`                                                     | 10 to 100                                                             | a short opens only in this upper share of the seven-day range; 100 is no zone. A ladder's: under 100 is refused for any other kind                                                                                                                                             |
| `universeCandidates` | `4`                                                      | 1 to 8, whole                                                         | with `markets: ["*"]`, how many markets the day's screen puts on the table                                                                                                                                                                                                     |
| `at`                 | `"00:30"`                                                | `HH:MM`, UTC                                                          | the hour of the day's deliberation, and of the schedule                                                                                                                                                                                                                        |
| `deliberations`      | `1`, or `3` for a strategy with a stop that does not say | `1`, `3` or `5`                                                       | how many voices decide                                                                                                                                                                                                                                                         |
| `votes`              | `first`                                                  | `first` or `all`                                                      | `first` runs the later deliberations only when the first proposes a trade; `all` always runs them                                                                                                                                                                              |
| `breakoutDays`       | `null`                                                   | `7`, `30` or `90`, or `none`                                          | a long only past the high of those days, a short only past their low, the extremes the dossier holds. Refused under a grid and a range                                                                                                                                         |
| `rsiExcess`          | `null`                                                   | 5 to 45, or `none`                                                    | a long only under this hourly RSI 14, a short only over 100 less it. Refused under a grid and a range                                                                                                                                                                          |
| `fundingFadePct`     | `null`                                                   | 10 to 1000, or `none`                                                 | a short only when the longs paid at least this many percent a year over the last seven days, a long only when the shorts did. Refused under a grid and a range                                                                                                                 |
| `decider`            | `model`                                                  | `model` or `code`                                                     | who decides the day's trade. `code` is a breakout armed by the code alone, with no model asked: it needs the stop kind, `breakoutDays` set and a trailing exit                                                                                                                 |
| `followLeaders`      | `false`                                                  | `true` or `false`                                                     | a long only where the top accounts of the leaderboard, read through hyperkeel, are net long on that market, a short only where they are net short; without their positions read, nothing opens. Refused for a grid and for a range, whose sides are the strategy's             |

### The method, by steps (`kind: "ladder"`)

| Field                 | Default           | Bounds                                               | What it does                                                                                                                              |
| --------------------- | ----------------- | ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `ladder`              | `[1, 1, 2, 3, 5]` | 1 to 8 steps, each 0.5 to 10                         | the steps, as multiples of the base stake                                                                                                 |
| `stepAtr`             | `0.5`             | 0.1 to 3                                             | the distance between two steps, in daily ATRs: the figure the two-year measure kept (0.75 and 1 were slower and left more positions open) |
| `targetPct`           | `10`              | 1 to 50                                              | the gain aimed at, in percent of the base stake, net of fees and funding                                                                  |
| `limitMaxDistancePct` | `3`               | 0.1 to 10                                            | a limit entry at most this far from the price, in percent                                                                                 |
| `reviewDays`          | `7`               | 3 to 30                                              | the term at which the trader is told to look again. By steps the code closes nothing then                                                 |
| `expectedHoldDays`    | `3`               | 1 to 30                                              | the days a position is expected to wait, for the funding counted against the target                                                       |
| `ladderMode`          | `price`           | `price`, `time` or `value`                           | the steps fall at their prices, or at their moments as a DCA, by the time or by the value                                                 |
| `dcaEveryDays`        | `7`               | 1 to 30, whole                                       | a DCA's steps, this many days apart                                                                                                       |
| `exitTiersPct`        | `null`            | 2 to 4 increasing percents from 0.5 to 50, or `none` | the exit by parts: each part rests as a limit that reduces at the average plus its percent. `none` takes the whole position at the target |

### The method, with a stop (`kind: "stop"`)

| Field                 | Default  | Bounds                         | What it does                                                                                                                                                                                         |
| --------------------- | -------- | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `stopAtrMin`          | `0.3`    | 0.1 to 1                       | the stop sits at least this far from the entry, in daily ATRs, so it is not noise                                                                                                                    |
| `stopAtrMax`          | `3`      | 1 to 5                         | and at most this far, so it is not an invented price. `stopAtrMin` must be below it                                                                                                                  |
| `minRiskReward`       | `2`      | 1.5 to 5                       | the gain at the target over the loss at the stop, **after every cost**, at least                                                                                                                     |
| `limitMaxDistancePct` | `3`      | 0.1 to 10                      | a limit or a trigger entry at most this far from the price, in percent                                                                                                                               |
| `reviewDays`          | `7`      | 3 to 30                        | after how many days a held trade gets its one review: keep, tighten the stop or close, never widen                                                                                                   |
| `stopExit`            | `target` | `target`, `trail` or `partial` | the trade ends at its target; or under a stop that trails and no take profit; or a part first, then the rest trailing                                                                                |
| `trailAtr`            | `3`      | 1 to 10                        | the trailing stop's distance, in daily ATRs, under the highest price since the entry (over the lowest for a short), never back                                                                       |
| `partialR`            | `1`      | 0.5 to 5                       | with `partial`, the part is taken at this many times the risk                                                                                                                                        |
| `partialShare`        | `0.5`    | 0.1 to 0.9                     | and this share of the position is taken; the stop then goes to the entry with both legs' fees                                                                                                        |
| `timeStopHours`       | `0`      | 0 to 720, whole                | a position still open this long after its fill is closed at the market. 0 is never                                                                                                                   |
| `pullbackAtr`         | `null`   | 0.1 to 3, or `none`            | the entry at most this many daily ATRs from the daily EMA 20, on the side of the trend: a long while the price is over the EMA 50, a short while under. A stop's alone: refused under any other kind |

Under `trail` and `partial` the target the trader names is still judged as the aim of the trade, so the size, the costs and the verdicts do not change, but it is not placed, and no review closes the position.

### The method, a grid (`kind: "grid"`)

| Field                   | Default | Bounds                       | What it does                                                                                                                                                       |
| ----------------------- | ------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `gridBias`              | `long`  | `long`, `short` or `neutral` | a long grid buys under the price and over it only sells what it holds, never net short; a short grid is its mirror; a neutral one trades both sides from the start |
| `gridLevels`            | `8`     | 2 to 20, whole               | the levels evenly spaced across the range, its two ends included                                                                                                   |
| `gridRangeHours`        | `168`   | 24 to 720                    | the range is the lowest low and the highest high of these hours; the day reads the dossier's range nearest it (the last day, seven, thirty or ninety days)         |
| `gridRangeTolerancePct` | `20`    | 0 to 50                      | a range the trader gives sits within this share of the measured one, edge by edge                                                                                  |
| `gridOutOfRange`        | `hold`  | `hold` or `stop`             | out of its range the grid keeps what it holds and waits, or closes everything at market                                                                            |
| `gridOutOfRangePct`     | `3`     | 0.5 to 20                    | with `stop`, how far beyond the range that happens, in percent                                                                                                     |
| `gridMinProfitBps`      | `10`    | 1 to 200                     | a grid whose round trip pays less than this, net of its two maker's fees, is refused                                                                               |
| `gridRestart`           | `again` | `again` or `done`            | a grid that ends is set again on the range of the moment, or the next day decides                                                                                  |
| `reviewDays`            | `7`     | 3 to 30                      | the term the brain judges a grid's decision over                                                                                                                   |

### The method, a range (`kind: "range"`)

| Field                  | Default    | Bounds                | What it does                                                                                              |
| ---------------------- | ---------- | --------------------- | --------------------------------------------------------------------------------------------------------- |
| `rangeHours`           | `6`        | 1 to 72, whole        | the range is the lowest low and the highest high of these hours                                           |
| `rangeLevels`          | `extremes` | `extremes` or `bands` | those extremes, or the bands of the last twenty hourly closes, two deviations from their average          |
| `rangeEntryBps`        | `5`        | 0 to 200              | each entry rests this many basis points inside its border                                                 |
| `rangeTargetShare`     | `0.65`     | 0.1 to 1              | the target sits this share of the range's width from the entry                                            |
| `rangeTargetFloorPct`  | `1.5`      | 0 to 10               | the width is taken as at least this share of the entry, in percent                                        |
| `rangeStopPct`         | `2`        | 0.1 to 10             | the stop sits this far beyond the border, in percent                                                      |
| `rangeStopCap`         | `1.5`      | 0.5 to 10             | and at most this many times the target's distance from the entry                                          |
| `rangeMinTargetPct`    | `0.2`      | 0 to 5                | a side whose target sits nearer than this to its entry, or that pays less than its fees, is not armed     |
| `rangeMinWidthPct`     | `0.5`      | 0.1 to 50             | a range narrower than this arms nothing                                                                   |
| `rangeMaxWidthPct`     | `8`        | 0.1 to 50             | nor one wider. `rangeMinWidthPct` must be below it                                                        |
| `rangeRefreshMinutes`  | `30`       | 5 to 1440, whole      | while nothing is filled, the range is measured again at this pace and an entry that moved is posted again |
| `rangeCooldownMinutes` | `30`       | 0 to 1440, whole      | after an exit, the session waits this long and arms again                                                 |

## Longs only

By default the pilot opens longs only, in the lower third of the week's range. With `sides: "both"`, which `ladder-both` ships, it opens shorts too, in the upper part.

The reason is a measure. On 4 October 2026, `lpa pilot calibrate --account` ran one account of 5000 USD over two years of four-hour candles (667 days with HYPE, all the exchange keeps), with the default ladder, a step of 0.5 daily ATR, fills counted 5 basis points through their level, and two positions at once:

| Markets                | Longs only                  | Longs and shorts            |
| ---------------------- | --------------------------- | --------------------------- |
| BTC and ETH            | +48.9 %, worst fall 23.9 %  | +78.6 %, worst fall 52.2 %  |
| HYPE, ETH, SOL and BTC | +119.0 %, worst fall 12.5 % | +226.5 %, worst fall 20.6 % |

The shorts add to the return, and to the worst fall. The worst fall of one run also depends on when it starts: the same measure on BTC and ETH, started eight and a half hours earlier, gave 9.6 % for the longs alone and 40.2 % with the shorts. Measure it on your own markets, from more than one starting day, before you choose:

```sh
lpa pilot calibrate --symbol BTC,ETH --interval 4h --days 730 --zones 33 --through 5 \
  --account --policies long-zone,long-zone+short-zone --concurrent 2
```

{% hint style="warning" %}
**Past figures are not a promise.** They say what the method did on those candles, with those settings. See [Measuring the method](https://doc.lockerprotocol.com/hyper-agentic-trader/calibrate.md).
{% endhint %}

## The universe

You do not have to name the markets. With `markets: ["*"]`, the one entry alone, the pilot considers every market that `lpa pilot universe --measure` kept, and screens them each day before anything else. The screen calls no model and costs nothing.

Each day, a market of the universe is **set aside**, by name and with its reason, when:

* the policy does not allow it, or it is not on the venue that day;
* its daily candles could not be read that day;
* its volume averaged over the last seven closed days, its open interest or its funding no longer pass the bounds the universe was measured with;
* the complete ladder, sized on your equity of the day, would be more than 1 % of the 24 h volume or 0.5 % of the open interest;
* its price sits in the middle of the week's range: a long is open only in the lower `longZonePct`, a short only in the upper `shortZonePct`.

The markets left are ranked by the score of the measure. A side that would pay more than 30 % a year of funding loses ten points, and the screen says so. The first `universeCandidates` are the markets of the day: the trader decides among them only, and reads, in a section of its dossier, each candidate with its side and its reason, then every market set aside and why.

Under a grid or a range the screen ranks differently: the markets the measure kept are ordered by how much their price went back and forth, the share of the path of its closes it undid, over the week for a grid and over the range's hours for a range within its widths. Their sides are the strategy's.

| What happens                                                                                               | What the day does                                                                                                       |
| ---------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| the screen leaves at least one market                                                                      | the day runs on the candidates                                                                                          |
| the screen leaves no market                                                                                | the day ends as `no-trade`, before any model is called                                                                  |
| the universe was never measured, was listed without a measure, or was measured more than fourteen days ago | the day warns you and trades BTC and ETH instead, within the policy, until you run `lpa pilot universe --measure` again |

The screen of each day is kept as `screen.json` beside the day's files, and in one line of `pilot.log`.

{% hint style="info" %}
**A position already held is always followed.** The follow reads the position's own plan, not the universe: a market that leaves the universe keeps its steps and its exit until the exit is reached.
{% endhint %}

{% hint style="warning" %}
**Measure first.** Run `lpa pilot universe --measure` before you set `["*"]`, and run it again every week or two. Try it on past days first: `lpa pilot replay --universe` plays your charter on the universe without changing anything. See [Replaying the past](https://doc.lockerprotocol.com/hyper-agentic-trader/replay.md#on-the-universe).
{% endhint %}

## The file, as `lpa` writes it

The charter holds its version, the name of its strategy, and its own figures, nothing else:

```json
{
  "version": 2,
  "strategy": "ladder-long",
  "riskPct": 1,
  "maxLeverage": 3,
  "leverage": 3,
  "liquidationMinPct": 100,
  "concurrentPositions": 2,
  "reinvestPct": 100,
  "costShare": 0.25,
  "modelShare": 0.1,
  "apiBudgetPerDayUsd": 0.5,
  "lossStreak": 3,
  "pauseHours": 72,
  "eventWindowHours": 12,
  "eventCurrencies": ["USD"],
  "eventSides": "short",
  "throughBps": 5
}
```

When the pilot chooses its strategy each day, three more keys say so: `strategies` (two to five names, the one in use among them), `choice` (`model` or `table`) and `table`. `lpa pilot strategy choice` writes them, and reads them back; see [The strategies](https://doc.lockerprotocol.com/hyper-agentic-trader/strategies.md#let-the-pilot-choose-each-day).

{% hint style="info" %}
**A charter written before it named its strategy still reads.** A file that holds all its figures, with no `version`, is read exactly as it always was, and its strategy is the shipped one whose figures it holds. The first change turns it into the file above; figures of its own that are no shipped strategy's are kept first as your strategy `my-charter`, so going back is one `lpa pilot strategy use` away. Nothing is lost.
{% endhint %}

## A careful charter, in three commands

One market, one position at a time, a smaller model budget, and the measure you made written down with it:

```sh
lpa pilot charter --set concurrentPositions=1
lpa pilot charter --set apiBudgetPerDayUsd=0.25
lpa pilot strategy save --name careful --from ladder-long --set "markets=BTC ladder=1-1-2-3" \
  --says "One market, four steps, the rest of the measured charter."
lpa pilot strategy use --name careful
```

## Where the figures should come from

Do not invent `stepAtr`, the ladder, the zones or a grid's levels. Measure them, from more than one starting day:

```sh
lpa pilot calibrate --symbol BTC,ETH --interval 4h --steps 0.5,0.75,1 --ladders 1-1-2-3-5,1-1-2-2-2
lpa pilot calibrate --symbol BTC,ETH --strategy grid-long --starts 6
```

Then write what you measured into the strategy's `notes`, with its date, so the trader reads the same thing you did. See [Measuring the method](https://doc.lockerprotocol.com/hyper-agentic-trader/calibrate.md).

## Learn more

* [The strategies](https://doc.lockerprotocol.com/hyper-agentic-trader/strategies.md)
* [How it trades](https://doc.lockerprotocol.com/hyper-agentic-trader/how-it-trades.md)
* [Your first simulation day](https://doc.lockerprotocol.com/hyper-agentic-trader/first-paper-day.md)
* [lpa pilot](https://doc.lockerprotocol.com/hyper-agentic-trader/commands/pilot.md)
