Use retained state and recover interrupted work

Reuse an acquired sequence or contextual correction without rebuilding its learner. Reconnect with the same authenticated owner and Domain IDs, then restore the vector meanings and executor conventions that give the retained state its meaning.

You want to	Use
Request an acquired sequence without learning	`propose` with `mode: "frozen"`
Execute a structural result	The saved `selected_execution` and its original adapter
Apply a retained contextual correction	`evaluate` with the current `context` only
Continue compatible practice	Resume the existing stage’s learning loop after reconciliation

Reuse the HTTP helper for the examples below. After a process restart or simulator reset, reconnect to the existing Domain and inspect its trajectory state. Preserve the coordinate meanings, timing, action bounds, and outcome definition from the preceding guides.

Save the integration manifest

Save	Why it is needed
Production base URL and stage Domain IDs	Reconnect to the same owned state
Requested and returned configuration	Reconstruct the mechanism and its resolved settings
State/action/context coordinate order, units, and scale	Preserve the meaning of numeric arrays
Executor version, residual scale, clipping, coordinate transforms, command duration, padding, and terminal rules	Execute the same numeric output consistently
Outcome definitions and ordered objective names	Keep feedback comparable
Exported records, incumbent ID, and selected base execution	Preserve stage handoffs and the base used by refinement
Context IDs, measured context vectors, and reset specifications	Reproduce each candidate comparison and its proposal bindings
Pending decision IDs, request bodies, and receipts	Reconcile interrupted operations

Retain credentials separately. An execution-record export contains acquired executions for transfer into a structural stage. Keep the original Domains available when you intend to continue learning from them.

Execute an acquired sequence without learning

The acquisition request schema supports mode: "frozen". Use the same current-state and goal arrays as acquisition, then execute the returned sequence with the same adapter. Save physical results locally without sending a training observation.

initial = reset_and_measure(evaluation_reset_key)
frozen = trajectory(ACQUISITION_DOMAIN, "propose", {
    "state": initial["state"],
    "goal": initial["goal"],
    "mode": "frozen",
    "request_id": f"{PREFIX}-evaluation-0001",
})
commands = frozen["actions"]
if (not finite_matrix(commands, 2) or len(commands) > 8
        or any(abs(value) > 1 for row in commands for value in row)):
    raise ValueError("Retained sequence violates the executor contract")
executable_commands = commands + [[0.0, 0.0] for _ in range(8 - len(commands))]
trace = execute_sequence(executable_commands)
journal("evaluation", {"proposal": frozen, "execution": trace})

This snippet reuses finite_matrix and the adapter hooks from Sequence acquisition. evaluation_reset_key identifies a saved evaluation scenario. Keep evaluation contexts separate from acquisition contexts when you want to assess behavior on new conditions. Measure task completion separately from the check that learned state remains unchanged.

Execute a selected base or retained correction

To use a structural result, execute the preserved base_execution["actions"] with its original adapter. The structural guide’s execute_candidate already applies the shared cadence, padding, and completion rule. For a contextual correction, call evaluate with the measured context only:

{
  "context": [0.5, 0.5, 0.0, 0.0]
}

POST to https://rei-neuroadapt-api.reilabs.org/api/v1/domains/{refinement_domain}/trajectory/evaluate. Replace the illustration with [target_dx, target_dy, initial_vx, initial_vy] measured for the current reset. Compute the first two values as goal[0] - state[0] and goal[1] - state[1], matching the refinement guide. Omit decision_id and candidate_index for retained use. Those two fields select a candidate within a pending training comparison. Use the returned offsets with the exact selected base, compose and bound the actions as shown in Contextual refinement, and record the resulting execution locally. Do not configure a new refinement Domain for each context. Compare the refinement state’s fingerprint before and after retained evaluation and send no observe calls. That checks the state exposed by the refinement mechanism; also keep the base and executor manifest unchanged.

Select from retained sequences

After acquisition, refinement, and freezing, planning can select among complete retained sequences. Generate candidates for the current target and bind each identifier to its exact command list and executor settings. Obtain their successor descriptions and comparison values, then ask native planning to select an identifier. Validate the returned identifier and execute its complete sequence. Define what one search step represents. If it represents a whole skill, depth one means one choice among skills, regardless of their command count. This workflow commits the complete sequence. First-action replanning requires a separately defined execution boundary. Record which values determined selection. A recorded control integration used exact simulator terminal_value scores for complete frozen candidates through /planning/adversarial. Those scores determined selection even though a learned value model was installed. The integration checked selection-to-execution binding and unchanged frozen state. Keep the candidate list, selected identifier, value source, completed depth, and execution trace together. See Planning integration for evaluator selection and search diagnostics for work counters.

Resume practice without restarting acquisition

Reload PREFIX and the saved Domain IDs. After reconciling pending work and inspecting trajectory state, continue the mechanism’s existing proposal and observation loop. A simulator reset starts a new environment attempt with the same compatible learned state. For contextual practice, preserve the same base, horizon, context encoding, objective order, and decoder. Use complete measured comparisons and include original conditions in the practice mix when preserving earlier behavior matters. A changed base or interface requires a new compatible refinement lineage. Keep these checks distinct:

Check	What it establishes
Unchanged learned state during evaluation	Frozen use of the inspected mechanism
Better outcomes on new reserved contexts	Performance on those unseen conditions
Matching results from a fresh client without feedback	Reuse of retained state across that reconnect

Save the base and executor alongside the correction so the reused policy is complete.

When practice stops improving

Use the proposal, execution trace, and observation receipt to find which part of the loop stopped contributing.

What you observe	Check next
Learning state stays unchanged after successful requests	Inspect the observation acknowledgement, pending decision, and applicable state version
Different candidate offsets produce identical executed controls	Check residual scaling, actuator decoding, clipping, and any fixed transform
Every candidate makes only a tiny correction	Inspect the current search radius and decoded action range; more repetitions of the same narrow search may add little coverage
One operating condition works and another fails	Inspect measured context delivery, numeric scales, context basis, and representative conditions in each comparison
Completion stays unchanged as graded quality improves	Check every required completion condition separately from the training objective
Outcomes regress on familiar conditions during continued practice	Include familiar and new conditions in comparisons and evaluate the retained policy on separate reserved cases

The precision settings document optional normalization, nonlinear context features, and measured-response guidance. Diagnose the missing coverage or control variation before changing the configuration. radius is an initial configuration setting. These guides do not define an in-place radius-update operation. Preserve the existing Domain and acquired base; use a new refinement stage for an incompatible configuration unless your deployment explicitly supports a state-preserving update. Do not use configure or reset as an undocumented way to expand exploration.

Record intent before each mutation

For configure, exploratory propose, and observe, durably record the intended request before sending it. After a response, save the returned IDs and receipt. Between proposal and observation, persist the physical execution and its measured outcomes first. All trajectory routes use POST, including reads such as state and records. Choose retry behavior from the operation’s effect on state. Use request_id for correlation and reconcile mutations before retrying; deduplication requires an explicit service guarantee.

Interruption	Recovery action
`state` or `records` response lost	Read again; keep the source learner stable during paginated export
Configuration response lost	Read trajectory state before attempting configuration again; compare with the saved intended configuration
Exploratory proposal response lost	Inspect state and available request records; recover the returned decision when possible before issuing another proposal
Physical execution interrupted	Keep the actual executed prefix and termination reason; for acquisition, report only measured rows
Candidate comparison interrupted	Resume the missing candidate/context executions; submit one complete matrix
Observation response lost	Preserve the exact observation and inspect state/receipts before resending; do not assume a timeout means rejection
Decision intentionally abandoned	Cancel it using its known `decision_id`; cancellation contributes no outcome

To cancel a known pending decision:

receipt = trajectory(domain, "cancel", {"decision_id": decision_id})
journal("cancel_receipt", receipt)

If you cannot determine whether a mutation was applied, pause that Domain’s writer and resolve the ambiguity from the service’s available state or operational records. Generating new IDs or replaying physical actions can make an uncertain operation harder to reconcile. trajectory/reset resets learner state. Structural intervention: "deletion" tests removing commands from an acquired execution.

Check requests before a long run

Use the same production base, Unit API Key, and mechanism that the run will use. Start with a fresh owned Domain and a small, measured acquisition or complete candidate/context comparison. Confirm configuration, returned IDs, array dimensions, observation acknowledgement, and subsequent readable state before increasing the budget. The shared helper rejects non-finite JSON and bodies over the reference 1 MiB limit. For comparisons, plan the full candidate count times context count before physical execution. Keep one writer per example Domain, finish pending work before exporting, and keep a durable record of every stage handoff.

Get started

Concepts

Guides

Planning

Discovery

Operations

API reference

Save the integration manifest

Execute an acquired sequence without learning

Execute a selected base or retained correction

Select from retained sequences

Resume practice without restarting acquisition

When practice stops improving

Record intent before each mutation

Check requests before a long run

​Save the integration manifest

​Execute an acquired sequence without learning

​Execute a selected base or retained correction

​Select from retained sequences

​Resume practice without restarting acquisition

​When practice stops improving

​Record intent before each mutation

​Check requests before a long run

Save the integration manifest

Execute an acquired sequence without learning

Execute a selected base or retained correction

Select from retained sequences

Resume practice without restarting acquisition

When practice stops improving

Record intent before each mutation

Check requests before a long run