Mid-Run Adjustments: When to Intervene and When to Leave It

The correct response to most uncomfortable readings during a live run is to take a second reading and change nothing. Intervention is justified when a reading has persisted across its window, when the response is reversible or its irreversibility is accepted deliberately, and when you can name what you expect the change to do. Anything else is fidgeting with real money attached.

This is not an argument for passivity. It is an argument for a ladder, because the alternative to a ladder is a binary in which every problem either gets ignored or gets the largest available response. The five rungs below cover everything an operator can do mid-run, and knowing which rung you are on is most of the discipline.

The default response is nothing

Runs are designed in advance precisely so that they do not require supervision decisions. If a plan needs continuous adjustment to work, the plan was wrong and the live window is the most expensive possible place to discover that. Treating no-action as the default is what makes the plan meaningful rather than decorative.

There is also an evidence problem. Every mid-run change breaks the comparability of the readings before and after it. If you adjust three things across an hour, the run produces one merged result that cannot be attributed to any of them, and the thresholds you set for next time will be based on a run you cannot interpret. Restraint is not only cheaper; it is what keeps the record usable.

The psychological pressure runs the other way, and it is worth naming. Watching produces a feeling of responsibility, responsibility produces an urge to act, and acting relieves the feeling regardless of whether it improves the run. Recognising that loop in yourself is a genuine operational skill, and the journal is where you catch it, because unscheduled checks followed by small adjustments have a distinctive look on the page.

The escalation ladder

Five rungs, in order of cost and reversibility. The rule is that you take the lowest rung that addresses the reading, and you go up one rung at a time unless a written stop condition tells you to jump.

1. Observe. Take a second reading at a defined time, change nothing, write both readings down. This is a real response with a real output, not an absence of one.
2. Adjust. Change a parameter the run reads while it is running: pace, size per action, which wallets participate. Reversible in the sense that you can change it back, though the work already done is not undone.
3. Pause. Stop new work starting, leave in-flight work to complete, keep state so the run can resume. The most misunderstood rung, because what it does to queued work varies by tool.
4. Stop. End the run as planned to end: no new work, in-flight work allowed to settle, then close-out begins. A stop is a decision to finish early, not an emergency.
5. Abort. End the run without waiting for orderly completion, accepting that some work may be half-done and that reconciliation will be harder. Reserved for situations where continuing is worse than an untidy ledger.

Each rung has a different relationship with time. Observe costs you one interval. Adjust changes the run from that point forward. Pause preserves optionality and consumes it slowly, because a paused run in an active market is not the same run when it resumes. Stop and abort end optionality entirely, and the difference between them is whether you are willing to spend the settlement window to keep the ledger clean.

From symptom to response

The table maps common live-window symptoms to the rung that usually fits, along with the two costs that decide it. It is a starting point for your own version, not a rule set: the right rung depends on how expensive an interrupted run is for you, and only you know that.

The two-reading rule

No adjustment on a single reading. Take a second one at the next scheduled check, from the same source, computed over the same window, and act only if both agree. The rule costs you one interval of delay and buys you immunity from the largest category of mid-run mistakes.

The rule has exactly two exceptions and they should be written down before the run. The first is a written stop condition, which fires on its own terms because it was designed to. The second is a reading that is definitionally instantaneous, such as discovering that the venue address is not the one you planned; there is no second reading that could make that acceptable.

Everything else waits for confirmation. If waiting one interval feels intolerable, that is a sign your check interval is too long for the phase you are in, and the correct fix is a denser cadence rather than a faster trigger finger. Changing the cadence is itself an adjustment, so write it in the journal.

The reversibility test

Before any action above the observe rung, answer three questions in order. They take about fifteen seconds and they catch the interventions that turn a bad hour into a bad week.

• If this change is wrong, can I put it back, and how long does putting it back take?
• What work will be in flight at the moment the change takes effect, and what happens to that work?
• What specifically do I expect to be different at the next check, and what would tell me the change did not work?

The second question is the one people skip. Adjustments do not apply to a frozen world; they apply to a run that is mid-action. A change to size per action that lands between submission and confirmation can produce a mixture of old and new behaviour that neither the tool nor your journal will explain later. Knowing where the boundary falls is part of knowing your controls.

The third question is what makes the change testable. An adjustment with no stated expectation cannot fail, so it cannot teach you anything, and you will make the same adjustment reflexively on the next run. Write the expectation in the journal at the moment you act, not afterwards.

Change one thing, and write down which

One change per interval. This is the oldest debugging discipline there is and it applies with more force here, because the environment is moving underneath you and you get no repeat runs to disambiguate.

If two things genuinely need changing at once, that is usually evidence that the correct rung is higher than adjust. A run that requires simultaneous changes to pace, size and fleet composition is a run whose plan no longer describes it, and pausing to rewrite the plan is cheaper than steering it live with three hands.

Resizing deserves particular caution, because it is the adjustment that feels most productive and does the most damage to the record. How large a campaign should be is a planning question with its own reasoning about how much volume a token needs, and that reasoning depends on inputs you cannot re-derive while watching a panel. Note the impulse in the journal, finish the run as planned, and settle the sizing question when you are not holding the controls.

A worked example of the ladder

The following walkthrough uses invented, illustrative values. Nothing here is a measurement, and the numbers exist only to show how the rungs connect.

Suppose the plan calls for a run of ninety minutes, with checks every ten minutes after the opening phase, and a signal sheet whose submission-health line reads: failure share over a ten-minute window, threshold set at a level you chose, action is adjust. At minute thirty the reading crosses your line for the first time.

Rung one, observe. You do not adjust. You note the reading, note that it is the first crossing, and set the next check for minute forty. You also note one thing the two-reading rule does not require but the journal makes easy: what else changed at around minute thirty, if anything.

Minute forty, second reading. If the failure share has returned inside the line, you write both readings down and continue, and you have spent nothing but ten minutes of patience. If it is still outside, you have a confirmed signal and the sheet says adjust.

Rung two, adjust. You change one parameter, and you write what you expect: reducing the submission rate should lower contention, so the next reading should move back inside the line by minute fifty. You do not simultaneously reduce size or drop wallets, because then minute fifty tells you nothing.

Minute fifty. If the reading improved, you record that the adjustment worked and continue on the new setting. If it did not, you have learned something more valuable than the adjustment: the cause is not the one you assumed, and the next rung is pause rather than a second guess at the same parameter.

Rung three, pause. Pausing stops new work and lets in-flight work settle, which gives you a stable picture to verify against the chain. This is where you check whether the failures share an error class, whether they concentrate on particular wallets, and whether the endpoint is answering correctly. Diagnosis is easier against a still run than a moving one, which is the underrated argument for pausing early.

The example ends without a resolution on purpose. Whether the run resumes, stops or aborts depends on what the diagnosis finds, and inventing that outcome here would be inventing data. The structure is the transferable part: one rung at a time, one change at a time, an expectation written before each.

Knowing what your controls actually do

Pause is the rung with the most variation between implementations. In some systems it stops the scheduler and lets everything in flight complete. In others it drops queued work entirely. In others it holds a lock that expires, so a pause left too long silently becomes a resume. Guessing which one you have, during the moment you need it, is a poor plan.

Whether you run your own scripts or a hosted professional Solana volume bot, decide before the run which controls exist, what each one does to work already submitted, and how you would confirm from the chain that the control took effect. That last part matters: a control that reports success in the interface has told you about the interface, not about the run.

Confirming from outside is straightforward if you set it up in advance. Note the most recent signature before you act, then check whether anything newer appears afterwards; a block explorer such as Solana Explorer is sufficient for this, and the account view will show activity for a wallet whether or not your tool reports it. If you want to understand what determines how long an in-flight transaction can still land, the client documentation at docs.anza.xyz covers block production and confirmation behaviour.

What over-intervening costs

The cost is not mainly financial, though it can be. It is that a heavily adjusted run produces no usable evidence. You cannot calibrate a threshold from a run in which you changed the conditions six times, so the next run starts from the same guesses as the last one, and the habit compounds across months.

There is a second cost that shows up in behaviour. Operators who intervene often learn, correctly, that their interventions are frequently followed by improvement, because readings that provoke intervention are usually extreme readings that would have regressed anyway. That is a reliable way to acquire false confidence in a set of reflexes, and the only defence is the journal, where an expectation written before the change can be compared with what actually followed.

Finally, over-intervening trains you to distrust your own rules. Each override of a written threshold makes the next override easier, and a rule that is routinely overridden is not a rule. If you find yourself overriding a threshold repeatedly, the correct response is to change the threshold deliberately between runs, not to keep overriding it live.

Adjustments that are almost always wrong mid run

• Increasing size because results look weak. This converts a disappointing run into a larger disappointing run and destroys the comparison with the plan.
• Adding wallets that were not prepared before the run. Unprepared accounts introduce funding, floor and configuration questions at the worst moment.
• Switching venue mid-flight. A different market is a different plan. Stop, decide, and start a run that describes what you actually want to do.
• Rewriting a threshold while it is firing. The threshold was set when you were calm; the version you write now is written to make the discomfort stop.
• Restarting to clear a problem you have not diagnosed. A restart hides the state that would have explained the failure, and the failure usually returns.
• Extending the run because it is going well. Extension is a budget decision, and budget decisions made while excited are the ones that show up in reconciliation.

The decision card

Keep this next to the signal sheet. It is deliberately short, because it has to be usable at the exact moment you least want to read something.

• Which rung am I on: observe, adjust, pause, stop or abort?
• Has this reading persisted across its window, or is this the first crossing?
• Is this a written stop condition? If yes, execute it and stop reading this card.
• What single thing am I changing, and can I put it back?
• What is in flight right now, and what happens to it when the change lands?
• What do I expect to see at the next check, and what would prove me wrong?
• Have I written the reading, the decision and the expectation in the journal?

The last line is the one that survives the run. Whatever you decide, the value of deciding it deliberately is that somebody, probably you, can reconstruct the reasoning later and improve it. A run that ends with a clean ledger and no record of why you acted has only half a result.