Readiness

Readiness is Euler’s judgement about whether a recording is fit to train on. It is a weighted blend of deterministic checks, renormalised over the checks that actually apply to the data at hand, and every check below its pass threshold raises a named flag that travels with the episode’s Readiness Receipt.

Nothing about it is a black box. Each check has a plain-language name, a stated reason it matters for training, a named downstream failure mode, a default weight, a default pass threshold, and a list of the data kinds it can never apply to.

The same checks are also presented grouped into three layers, because “was this captured correctly”, “do the labels describe what happened” and “will this help my model” have different owners and different fixes. See data utility.

The checks

There are twelve. Weights are the platform defaults; the weight actually in force for your project is served by the settings endpoint below.

Check	What it measures	Default weight	Flag when it fails
`timestamp_gap`	Timeline continuity: no missing time between frames	0.15	`timestamp_gaps`
`timeline_jitter`	Clock stability: frames arrive at a steady rate	0.10	`high_jitter`
`action_smoothness`	Control smoothness: commanded motion is physically plausible	0.15	`erratic_control`
`idle_segments`	Dead time: little wasted head and tail	0.05	`idle_head_tail`
`trajectory_completeness`	Complete attempts: episodes start settled and finish the task	0.10	`incomplete_trajectory`
`stream_sync`	Sensor alignment: cameras and telemetry agree on when things happened	0.05	`stream_desync`
`episode_length_z`	Length consistency: no wildly odd-length episodes	0.10	`length_outlier`
`gripper_event_sanity`	Gripper signal: open and close events look real	0.10	`gripper_signal_suspect`
`language_action_align`	Instruction match: the written task matches what happens	0.10	`language_action_mismatch`
`camera_dropout`	Camera coverage: every declared camera actually recorded	0.10	`missing_camera_stream`
`image_integrity`	Image quality: frames are sharp, exposed and readable	0.0	`low_image_quality`
`annotation_coverage`	The annotation layers you enabled actually produced labels	0.10	`thin_annotation_coverage`

Most checks pass at 0.5. camera_dropout passes only at 1.0: a declared camera that did not record is a defect, not a degree.

image_integrity carries a default weight of 0.0 in the standard blend and becomes the deciding signal for the vision-asset kind, where the timeline and kinematic checks do not exist at all.

What each check means for training

The point of a check is the consequence of ignoring it.

Timeline continuity

A policy learns the rhythm of a task from the gaps between frames. Missing time teaches it that the world jumps. Downstream: jumpy rollouts and mistimed grasps at inference. Needs: per-frame timestamps.

Clock stability

Unstable frame timing quietly changes the effective control rate, so a model trained on it learns the wrong speed. Downstream: actions that fire early or late once deployed. Needs: per-frame timestamps.

Control smoothness

Erratic teleoperation is copied faithfully by behaviour cloning. Clean demonstrations are the cheapest quality win available. Downstream: shaky, unsafe motion in the learned policy. Needs: an action or state timeseries.

Dead time

Long idle stretches teach a model to wait, and they inflate training cost for frames that carry no task signal. Downstream: policies that hesitate before acting. Needs: an action or state timeseries.

Complete attempts

A truncated demonstration teaches the ending it never showed. Complete attempts are what a policy needs to imitate. Downstream: policies that abandon tasks near the end. Needs: an episodic commanded trajectory, which is why this check does not exist for egocentric, drive-log, aerial or vision-asset data.

Sensor alignment

If the camera and the arm disagree by even a few frames, the model learns to act on what it has not seen yet. Downstream: confident actions taken on stale observations. Needs: two or more timed streams.

Length consistency

Outlier-length episodes are usually a capture bug, not a rare skill, and they dominate batch statistics. Downstream: skewed training batches and unstable loss. Needs: more than one episode.

Gripper signal

The gripper channel is the highest-signal, lowest-dimension part of a manipulation demonstration. Noise here poisons grasping. Downstream: policies that open the gripper at the wrong moment. Needs: a gripper channel.

Instruction match

Vision-language-action models ground on the instruction. A mismatched task string teaches the wrong association directly. Downstream: models that follow instructions incorrectly. Needs: a task description.

Camera coverage

A missing view at training time becomes a missing view at inference time, and multi-view policies fail closed. Downstream: views the model expects but never receives. Needs: at least one camera.

Image quality

Blur, blowout and compression artefacts are learned as features. Vision encoders happily fit noise nobody wanted. Downstream: brittle perception that degrades on clean data. Needs: image or video frames.

Annotation coverage

A dataset is only as trainable as its labels are complete. This check reports what each enabled annotation layer actually produced. Downstream: silent gaps that surface as label noise in training. Needs: at least one annotation layer enabled.

Applicability

A check that a class of data cannot physically satisfy is removed from the blend before scoring, not scored as zero. An egocentric human clip has no commanded trajectory to complete and no gripper to be sane about; a drive log never settles the way a demonstration does; a state-only log has no cameras to drop; a loose image has no timeline at all.

The data kind is derived automatically from what the episode contains and decides which checks exist. The remaining weights are renormalised, so an episode is never penalised for a contract its class of data cannot have.

Two registries agree on this gate: the data-kind registry is the authority the scorer uses, and the check catalog carries the same information so the settings screen can explain the reason in plain language.

Reading and configuring readiness

curl -fsS -H "Authorization: Bearer $EULER_TOKEN" \
  "$EULER_BASE_URL/v1/projects/$PROJECT/readiness/settings"

For every check the response gives the catalog row plus what is in force for this project: enabled, the effective weight and threshold, whether it applies to this project’s episodes and the reason when it does not, and the applicable episode count. It also reports max_threshold_offset, the furthest a threshold may be moved.

Changing configuration needs the engineer role and is audited:

curl -fsS -X PUT -H "Authorization: Bearer $EULER_TOKEN" \
  -H "Content-Type: application/json" \
  "$EULER_BASE_URL/v1/projects/$PROJECT/readiness/settings" \
  -d '{
        "disabled": ["idle_segments"],
        "threshold_offsets": {"action_smoothness": -0.1},
        "weight_overrides": {"camera_dropout": 0.2},
        "certificate": true
      }'

Every field is optional; omitting one leaves it untouched and an empty value clears it back to the default. Only differences from the defaults are stored, so a project that never opens the screen scores exactly as it did before the screen existed.

Thresholds are bounded on purpose. A threshold offset is clamped to ±0.3 and a weight override to the range 0 to 1. A team can tune a check when their domain legitimately disagrees with the default. A team cannot silently define a failure away, because a certificate that can be tuned to always pass would not mean anything.

Unknown check ids are rejected outright. Out-of-range values are clamped rather than rejected, so a stale stored setting can never break scoring.

Certificates

Setting certificate: true makes the project seal an Euler Certified Report. That answers a different question from a dataset export: whether the current source evidence is suitable for a named training target under a pinned policy. It never rewrites or copies training media.

Each metric in the report exposes its observed value, formula, inputs, provenance, confidence, applicability, ideal boundary and review boundary. The aggregate verdict is certified, review_required, not_ready or not_assessable. Missing modalities reduce evidence coverage instead of silently becoming zero or pass.

Certification policies are immutable and content-hashed. A reviewer can adjust target-dependent defaults, but saving creates a new version and prior reports are retained. See the data assessment guide.

Split this score into integrity, semantic quality and utility, and see what has not been measured: Data utility.
Select a training subset from what scored well: Curation.
See what the annotation layers actually produced: Annotation layers.