runs

Filter by executor (worker | modal).

Filter by billing owner handle (username or org slug).

UI2 — filter by kind: external (imported), orchestration (a plan's run), cloud (executed; narrow further with executor).

UI2 — filter by the robot the recipe names (owner/slug, exact), or the literal none for runs whose recipe names no robot.

UI2 — true: only runs that carry a scorecard (gate non-null); false: only runs without one.

UI2 — the direct forks of one run (its lineage children).

UI2 — true adds facets to the page: how the caller's whole visible set (this request's filters NOT applied) splits by kind, executor, status, robot and gate, so a filter rail can print a count beside every choice. Default false; the CLI never pays for it.

Page size.

Opaque cursor from the previous page's next_cursor.

Page of runs.

Missing or invalid credentials.

Client-chosen key that makes a create retry-safe. Scoped to the credential (API key, or session user): within 24 h the same key with the same body returns the original resource with 200; the same key with a different body is 422. Keys are opaque to the hub; a UUID is a fine choice.

Billing owner handle; defaults to the caller's username.

Lineage — the run this one forks/retrains from.

Replay — this Idempotency-Key already created a run with this body; that run is returned unchanged.

Run queued.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Request failed validation.

The account's (or the key's own) daily GPU-hour quota would be exceeded (priced executors only). Retry-After says when hours free up; nothing was recorded.

The requested executor cannot run on this deployment (modal with no MODAL_APP_NAME, or a template no deployed function carries), or the template is registered for planning only (pi0_lora, groot_lora, openvla_lora — M7-RL ③). Nothing was recorded.

Owner handle; defaults to the caller's username.

Lineage. Set it whenever one exists — the coach's first piece of attribution evidence is this run's resolved config diffed against the parent's.

What produced the run, free text. Defaults to external.

Dataset refs the run trained on, if any. A simulator-only RL run legitimately has none.

Run imported.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

An artifact is over the per-artifact size limit, or the owner's storage quota would be exceeded (L0: imports count toward it).

Request failed validation.

Billing owner handle; defaults to the caller's username.

Lineage — the run this one forks/retrains from.

The estimate.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Request failed validation.

Billing owner handle; defaults to the caller's username.

Lineage — the run this one forks/retrains from.

The recommendation, with its arithmetic.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Request failed validation.

Training run id (run_...).

The run.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Resource not found (or hidden from the caller).

Training run id (run_...).

Keep the stream open while the run is queued/running.

Replay only the last N log lines (default = all). Metric events are never tailed.

L1 — remove ANSI escape sequences (colour, bold, cursor control) from every log line before it is sent. Off by default: the log is the trainer's bytes, and a terminal pane renders rsl_rl's bold header from them. An agent reading text sets it (the MCP get_run_logs tool does).

SSE log stream.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Resource not found (or hidden from the caller).

Training run id (run_...).

L1 — remove ANSI escape sequences (colour, bold, cursor control) from every log line before it is sent. Off by default: the log is the trainer's bytes, and a terminal pane renders rsl_rl's bold header from them. An agent reading text sets it (the MCP get_run_logs tool does).

The whole log.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Resource not found (or hidden from the caller).

Training run id (run_...).

Cancellation requested; current run snapshot returned.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Resource not found (or hidden from the caller).

State conflict (duplicate handle/slug, wrong repo kind, terminal job, ...).

The run's executor cannot cancel on this deployment (modal).

Training run id (run_...).

The flattened config and the diff.

Missing or invalid credentials.

Resource not found (or hidden from the caller).

Training run id (run_...).

Checkpoints by step, oldest first.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Resource not found (or hidden from the caller).

Training run id (run_...).

A name for the runner — its hostname, or anything the operator will recognise on the run page. Recorded as claimed_by.

C1. The Modal function call the claiming container is running (modal.current_function_call_id()). Only meaningful on a re-claim: Modal preempts GPU containers and restarts the same input in a new one, which then claims a run that is already running. The hub accepts that claim when the run is a modal run, this id equals the run's modal_call_id (stored at dispatch) and the credential is the one that claimed it first; anything else is still 409.

C1, re-claim only. The checkpoint step the restarted container will resume from — one of the steps listRunCheckpoints already lists for this run (422 otherwise), or null to restart from scratch. The hub drops the lost attempt's metrics.jsonl lines past that step (all of them when null), so the curve has one start, and writes a stderr notice into the log.

Claimed; the run as it now stands.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Resource not found (or hidden from the caller).

State conflict (duplicate handle/slug, wrong repo kind, terminal job, ...).

Request failed validation.

Training run id (run_...).

Omit (or running) for a progress report. succeeded / failed are terminal and may be sent once; canceled is terminal too and is accepted only after cancelRun set cancel_requested_at.

Metrics lines to append to metrics.jsonl, oldest first.

Raw stdout/stderr since the last report, ≤ 256 KiB of UTF-8.

Failure summary; expected with status: failed.

The template's RESOLVED config, stored at config_key. Send it once it exists — it is the coach's first attribution evidence. L1: the runner sends it on the first progress report after the template wrote config.yaml (so getRunConfig answers while the run trains), and again at the end only if the file changed; each one replaces the stored object.

Acceptance scorecard, stored at scorecard_key.

owner/slug of the model repo the runner published.

Peak GPU memory the template used, in GB (M7-RL ③). Echoed on the run; on a succeeded terminal report it updates the rolling measured value recommendRun prefers over its own arithmetic.

Training throughput, samples per second (M7-RL ③). Same handling as peak_vram_gb.

Which tier class the GPU that ran the template belongs to (M7-RL ③). Absent, the run's own gpu_type is used; absent too, the measurement is filed under other.

L1 — where the run stands, sent on progress reports; each report's object replaces the last and is echoed as Run.progress (with the ETA the hub computes at read time).

Recorded; the run as it now stands.

Missing or invalid credentials.

Authenticated but not allowed (visibility, membership or scope).

Resource not found (or hidden from the caller).

State conflict (duplicate handle/slug, wrong repo kind, terminal job, ...).

A log chunk, metrics batch or artifact is over its size limit, or what the report would store puts the run owner past their storage quota (L0); nothing was stored.

Request failed validation.

The tier table.

Missing or invalid credentials.

UI2 — present only when listRuns?facets=true.

Billing owner handle; defaults to the caller's username.

Lineage — the run this one forks/retrains from.

Resolved GPU type the run is billed on.

Accrued cost in USD (4 decimal places).

Storage key of the metrics: runs/{id}/metrics.jsonl for an executed run (appended by reportRun), runs/{id}/metrics.txt for an imported one.

Storage prefix of the log chunks, runs/{id}/logs/ — one object per reportRun that carried a log_chunk, named so that lexical order is arrival order. Always null for an external run — it was not trained here, so there is nothing to stream.

Storage key of the resolved training config (M14b). The coach's attribution evidence #1 is the diff of this against the parent's.

Storage key of the acceptance scorecard JSON (M14b).

UI2 — the scorecard's verdict as two numbers, on every read: how many of its PASS/FAIL rows pass (the same reader the coach uses, gates declared or discovered). Null when the run has no scorecard — a plan's run never has one, an executed run gets one when a sim-gate rollout scores it, an imported run when it was imported with one. Stored when the scorecard is written, so a list page costs no object reads.

UI2 — every PASS/FAIL row of the scorecard, getRun only (null on list pages); read from the scorecard object on each read.

Model repo produced on success.

Lineage — the run this one forks/retrains from.

Which backend runs it (M7-RL). Null for an external run.

The runner name given to claimRun (M7-RL).

Last time the runner claimed or reported (M7-RL).

Set by cancelRun on a running run (M7-RL). The run is still running; the runner is expected to stop the template and report status: canceled. Null once the run is terminal by any other route, and always null for a run nobody asked to cancel.

The last metrics line the runner reported (M7-RL).

Peak GPU memory the template used, in GB, as the runner last reported it (M7-RL ③). Null until a report carries one.

Training throughput the runner last reported, samples per second (M7-RL ③). Null until a report carries one.

The Modal function call executing a modal run (W13), set by the dispatch job after the run was recorded; cancelRun terminates it. Always null for a worker or imported run.

When the hub spawned the modal call (W13) — the moment between queued and the container's claim. Null for a worker run.

Failure summary when status is failed.

L1 — what to call the run before (and after) its output repo exists: the name of the campaign round that owns it, else recipe.hyperparams.run_name, else the output model repo's slug, else the template. display_name_source says which.

L1 — iteration, total, iterations/s and ETA as the runner last reported them; null until a report carries progress (a queued run, an imported one, a template that declares nothing).

L1 — what the run has cost so far and what is left of its budget, computed on every read by the function that bills it at the end.

L1 — the campaign round that owns this run (C3), when there is one the caller can see; null otherwise.

AG1 — the reward curve decimated to at most 64 points, kept by the hub as the runner reports metrics; null until a metrics line carries a reward.

Owner handle; defaults to the caller's username.

Lineage. Set it whenever one exists — the coach's first piece of attribution evidence is this run's resolved config diffed against the parent's.

What produced the run, free text. Defaults to external.

Dataset refs the run trained on, if any. A simulator-only RL run legitimately has none.

Resolved GPU tier (recipe.gpu, else l4); null for a worker run, and (F1) for a modal template hosted on CPU (ppo_mujoco), whose rate is its host alone.

Billed hourly rate (4 decimal places): the tier's, plus host_rate_usd_per_hour; 0 for a worker run. This is the rate the run is billed at, second by second.

C1. The part of rate_usd_per_hour that pays for the CPU cores and memory the template's Modal function reserves beside the GPU (Modal bills them on top of the GPU): ppo_isaac 8 cores + 32 GiB; F1: ppo_mujoco 6 cores + 4 GiB with no GPU, so there it is the whole rate; 0 for every other template. Always 0 for a worker run.

recipe.max_hours, or the service default of 4.

rate_usd_per_hour × max_hours, then min(budget_usd) when a budget is set.

The recipe's hard cap, echoed.

True when budget_usd is what bounds cost_usd_max.

False when the executor is not billed by the hub (worker), so a zero is "not charged", not "free GPU time" — the same rule the coach uses for an unknown model id.

False for a planning-only row — createRun answers 503 for it.

The smallest tier that fits with headroom; null when none does.

recipe.gpu, echoed, so why[] can say whether it fits.

The estimate itself (modelled or measured), before headroom.

vram_estimate_gb × (1 + headroom), or the published floor when higher.

The safety margin applied (0.2 unless the deployment changed it).

Every tier whose VRAM covers vram_required_gb, smallest first.

Expected wall clock on tier; null when the registry has no throughput reference and no run measured one.

The tier's billed rate plus the template's host rate (C1, ppo_isaac); 0 for a worker recipe.

rate × est_hours; null when est_hours is.

rate × max_hours (service default 4 h), capped by budget_usd — what estimateRun would answer for this tier.

The arithmetic, one step per line, with the source URL of every published number.

Reserved for M16 (a model's prose over this plan). Always null in v0.

Every leaf of this run's resolved config, sorted by path. Empty when the run has no readable config.

keys.length.

Null when there is no parent, or one side has no parseable config — reason says which.

Why keys is empty or diff is null, in one sentence; null when nothing is missing.

L1 — this run's config shape: isaac (Isaac Lab's resolved env.* / agent.*, ppo_isaac), manifest (a stamped contract — contract.* / plant.*, what the importer and the stub templates write), other, or none without a readable config.

The parent's config shape; null without a visible parent.

How the diff was computed (RunConfigDiff.comparison); null without a diff.

L1 — the keys and the diff by RL structure, in the rule table's order, every group listed (a group with nothing in it on either side has total: 0), so a page can say what an imported manifest does not carry.

cross_shape only: the key pairs compared. [] otherwise.

The owning round's declared keys and what the diff says about each; [] off a round.

The output model repo the checkpoints live in; null when none exists yet.

WA — why this run cannot be a fine-tune's parent, in one sentence: set when the run has ended (or was imported) and published no checkpoints/step_N/. The sentence is RoundPreview.not_fine_tunable's (K3), readable here without a campaign, so a page can say it before any form exists. Null while the run may still publish one, and whenever items is not empty.

A name for the runner — its hostname, or anything the operator will recognise on the run page. Recorded as claimed_by.

C1. The Modal function call the claiming container is running (modal.current_function_call_id()). Only meaningful on a re-claim: Modal preempts GPU containers and restarts the same input in a new one, which then claims a run that is already running. The hub accepts that claim when the run is a modal run, this id equals the run's modal_call_id (stored at dispatch) and the credential is the one that claimed it first; anything else is still 409.

C1, re-claim only. The checkpoint step the restarted container will resume from — one of the steps listRunCheckpoints already lists for this run (422 otherwise), or null to restart from scratch. The hub drops the lost attempt's metrics.jsonl lines past that step (all of them when null), so the curve has one start, and writes a stderr notice into the log.

Omit (or running) for a progress report. succeeded / failed are terminal and may be sent once; canceled is terminal too and is accepted only after cancelRun set cancel_requested_at.

Metrics lines to append to metrics.jsonl, oldest first.

Raw stdout/stderr since the last report, ≤ 256 KiB of UTF-8.

Failure summary; expected with status: failed.

The template's RESOLVED config, stored at config_key. Send it once it exists — it is the coach's first attribution evidence. L1: the runner sends it on the first progress report after the template wrote config.yaml (so getRunConfig answers while the run trains), and again at the end only if the file changed; each one replaces the stored object.

Acceptance scorecard, stored at scorecard_key.

owner/slug of the model repo the runner published.

Peak GPU memory the template used, in GB (M7-RL ③). Echoed on the run; on a succeeded terminal report it updates the rolling measured value recommendRun prefers over its own arithmetic.

Training throughput, samples per second (M7-RL ③). Same handling as peak_vram_gb.

Which tier class the GPU that ran the template belongs to (M7-RL ③). Absent, the run's own gpu_type is used; absent too, the measurement is filed under other.

L1 — where the run stands, sent on progress reports; each report's object replaces the last and is echoed as Run.progress (with the ETA the hub computes at read time).

Every run the caller can see.

external and orchestration; executed runs are split by executor instead.

By recipe.robot; none for runs whose recipe names no robot.

true (carries a scorecard) and false.

Which trainer runs. Free-form so an imported run can name whatever produced it (external, isaac-lab-ppo); the ids the platform knows are ppo_isaac (the Isaac Lab PPO stack behind the published Laika policies — on a self-hosted worker, or since C1 hosted on modal for owners in the deployment's ISAAC_HOSTED_OWNERS allow-list, NVIDIA's licence permitting the hub's own org and nobody else; on the RT-core tiers only), ppo_mujoco (M17b: a real, robot-agnostic PPO trainer on MuJoCo, built into the CLI — lucen-cli[rl] — and driven entirely by the robot card's interface; runs on a worker, or since F1 hosted on modal on a CPU-only container — no GPU is attached or billed, so gpu must be null there) and stub_ppo (a seconds-long stand-in that emits the four artifacts; CI and acceptance use it). M7-RL ③ adds the VLA family: smolvla_lora (LoRA fine-tune of SmolVLA on a LeRobot dataset repo, built into the CLI, control class skill), stub_skill (a seconds-long skill-class stand-in), and the planning-only rows pi0_lora, groot_lora, openvla_lora (recommendRun answers for them; createRun is 503). A runner serves the templates it was started with and leaves the rest queued.

The robot this run trains for, as the owner/slug of a robot repo the caller can see. M17b: validated on createRun, estimateRun and recommendRun — anything else is 422, and a private repo answers exactly as a missing one does, so run creation is not an existence oracle. The runner stages the repo's robot_card.json for the template, and for a template that simulates the robot (ppo_mujoco) its MJCF and every asset it names. importRun does not validate it: an imported run records something that already happened and may name whatever it named.

Template-specific hyperparameters (opaque in v0).

GPU type; service default applies when null. l4 is the low-cost tier for small finetunes (ACT/SmolVLA on modest datasets); M7 owns the rate table. l40s (C1) is the 48 GB RT-core card Isaac Sim is hosted on: a modal ppo_isaac run with a null gpu is recorded on l40s, and a100 / h100 (no RT cores) are 422 for it. F1: a modal ppo_mujoco run runs on CPU and records no tier; naming a GPU for it is 422.

Hard wall-clock cap; the run is stopped at the limit (a worker runner kills the template and reports failed). Null means the service default, 4 h, which is also what estimateRun prices.

Which backend executes the run (M7-RL). Null means worker, the only executor that can run on this deployment today.

Hard spend cap in USD (M7-RL). estimateRun caps cost_usd_max by it; a billed executor stops the run when accrued cost reaches it. For a worker run the hub bills nothing, so the cap is recorded on the recipe and never binds.

Gate checkpoints in simulation while the run trains, and stop it on a tripwire (C2). Needs robot: 422 otherwise.

C1. Start this run from the parent run's checkpoint at this step, not from scratch: the runner downloads the parent's checkpoints/step_{N}/ into the template's input/resume/ and writes input/resume.json ({"source": "parent", "run_id", "step", "files"}); a template that can resume (ppo_isaac, stub_ppo) continues from those weights. Requires parent_run_id, and the parent's output model repo must list checkpoints/step_{N}/ — anything else is 422 on createRun and estimateRun, so a typo is refused before a GPU starts. Null (the default) keeps M7-RL's behaviour: the child inherits the parent's contract and trains from scratch.

Zero when the scorecard states no PASS/FAIL row the reader recognises.

The row's own measurement text (20/20 survival, tilt median 6.1 deg).

The newest iteration the metrics show, in the trainer's own numbering.

The number the trainer counts to, as it prints it — rsl_rl's Learning iteration 1412/2300 has 2300 (the start step plus max_iterations). Null when the template declared none.

The last iteration the trainer will log: total_iterations − 1 for a zero-based trainer (rsl_rl), total_iterations for one that counts from 1 (stub_ppo). What fraction and the ETA count to.

0 from scratch; the parent's checkpoint step on a resume from a parent (C1), the resumed step after a preemption.

Measured over the last minute of metrics lines; null until two lines exist.

(iteration − start_iteration) / (final_iteration − start_iteration), clipped to [0, 1].

Seconds left at this read: (final_iteration − iteration) / iterations_per_s, less the seconds since as_of. Null when the run is terminal or either number is missing.

as_of plus the remaining iterations at the measured rate.

The metrics key the iteration was read from (iter, iteration, step, …).

When the hub received the report this was read from.

USD to 4 decimal places.

The billed rate, tier plus host (estimateRun's rate_usd_per_hour).

recipe.budget_usd, echoed.

max(budget_usd − accrued_usd, 0); null without a budget.

True once the run is terminal and accrued_usd is the bill.

The campaign owner's handle.

The round's index in its campaign.

The round's name.

The metrics key it follows (Train/mean_reward, else mean_reward, else reward).

[step, value] pairs, oldest first.

The RESOLVED training config, not the source template.

Metrics as text (CSV, JSONL tail, or a table).

Acceptance results; PASS rows become standing constraints.

Tier the measurements came from (other when the runner named none).

Highest peak reported so far.

Running mean of the reported throughput.

hyperparams.batch_size for imitation learning, hyperparams.num_envs for RL, else the registry default.

The side of the square image the model actually sees (VLAs resize their inputs).

A flattened leaf path (env.events.push_robot.params.velocity_range[0]).

The leaf's value, rendered as text and elided past 200 characters.

WA — on RunConfig.keys[]: the RL structure the key falls in, by the one rule table (groups[].id), so a client can list EVERY key of a group (a fine-tune form's editor) without a second copy of the table. Absent on groups[].own_keys, whose group is the one that holds them.

Changed keys beyond the first 120, not listed.

L1. same_shape — both configs are compared path for path (the M14b diff, unchanged). cross_shape — one is the importer's manifest shape and the other Isaac Lab's resolved env.* / agent.*: entries and unchanged_keys cover only the mapped pairs (RunConfig.pairs), and every key with no counterpart is counted in parent_has_no_record / child_has_no_record, never as added, removed or unchanged.

cross_shape: this run's keys the parent's config has no counterpart for.

cross_shape: the parent's keys this run's config has no counterpart for.

How a page titles it: Actions, Algorithm · PPO, Plant · Scene, Sim · scale, …

False for bookkeeping, whose keys change on every run by construction.

The parent's keys in this group; null when there is no diff.

The group's changed keys (same shape; added and removed keys included), in path order; [] without a diff.

The first unchanged key by path, for a "first … last" summary line.

P1 — this run's own keys and values in the group that were NOT compared with the parent: the keys the parent has no record of (parent_has_no_record, a cross_shape comparison), or every key of the group when there is no comparison at all. In config order, at most 200 (own_truncated counts the rest); [] when every key was compared.

P1 — own_keys beyond the first 200, not listed.

P1 — own_keys as one line a person reads, by the summary rule (docs/API.md "Config summaries"): names relative to the group, a reward term as its weight, an array of one value as name[0..11] = v, at most 12 items then +k more. Null when own_keys is empty.

P1 — the group's unchanged keys as one line, by the same rule; on a cross_shape comparison one item per pair rule, this run's key value ⇄ the parent's key (n) (e.g. scale 0.5 ⇄ action_scale_vec[0..11]). Null when nothing was unchanged.

The parent's value, rendered; null when the parent lacks the key.

This run's value, rendered (after the pair's conversion, e.g. sim.dt × decimation → Hz).

Null when either side lacks the key (the pair could not be compared).

How the two were made comparable, in one phrase.

P1 — the RL structure the key falls in by the one rule table, so a declared key the parent never recorded still sits under its group (a command mode under commands).

P1 — this run's value(s) under the key, one line by the summary rule (docs/API.md "Config summaries"); null when this run's config holds nothing under it.

The directory, e.g. checkpoints/step_1000/.

AG1 — when the step's last file landed (the ONNX is pushed last, so this is when the checkpoint became complete).

The newest iteration in metrics.jsonl.

USD per GPU-hour as billed — the hub's margin is already included; there is no cheaper number. A template whose Modal function reserves a large CPU host beside the GPU (ppo_isaac: 8 cores, 32 GiB — C1) adds that host's billed rate on top; estimateRun shows it as host_rate_usd_per_hour. A template hosted on CPU alone (ppo_mujoco, F1) pays that host and no tier.

K2 — the monthly hosted allowance every account outside owners gets for CPU work; null when it is off (HOSTED_ALLOWANCE_USD=0, L0's behaviour exactly) or nothing is hosted.

A Modal app is configured (MODAL_APP_NAME). False: every modal request is 503 whoever asks.

HOSTED_OWNERS=*: any owner may use modal.

The owner handles (users or orgs) the hub hosts for, lower-case; empty when everyone. A rollout also needs write access to its model.

The filter value that selects this bucket (external, worker, succeeded, lucen/laika, none, true).

Gate the first checkpoint at or past each multiple of this.

Control steps of actuation delay (watch_ckpt.py --delay 2, the real link's upper bound).

Null means the run's own executor.

L1 — what each gate rollout renders. Null keeps C2's behaviour (full: three views per cell). A campaign round on a walk or omni task is gated on c_matrix × 5 seeds with poster (the founder's call, 2026-09-26): physics plus one still per cell, so a gate lands in minutes; the three views stay on the 20-seed band scan, and any gate's can be rendered later (renderRollout).

P1 — the seconds each seed runs, as the battery defines it for the run's robot (c_matrix 20 s, recovery 10 s). Filled by the hub wherever it returns the spec (Run.recipe.gate, AgentPlanRound.gate); a value sent in a request is ignored and never stored — the battery decides, as the gate always did.

P1 — how many cells the battery runs on the run's robot (c_matrix 13; smoke 5 on legs, 3 on a fixed base). Filled and ignored like horizon_s.

The parent's value; null when the key is absent there.

This run's value; null when the key is absent here.

C3 — for a campaign round's run: true when the key lies inside the round's declared change, false when it does not (the one-variable rule counts it), null when the run is in no round or the key is bookkeeping that changes on every run by construction (run.*, the run ids, the iteration cap) and is never counted.

L1 — the RunConfigGroup.id this key falls in (docs/API.md "Config groups").

L1 — on a cross_shape comparison, the parent's key this run's path was mapped to (contract.action_clip for env.actions.joint_pos.clip); null when both sides use the same path.

What the allowance covers, by name.

The caller's own account this month; null when anonymous, or when the caller is in owners (no allowance applies).

Settled spend this month (ledger rows of finished hosted jobs).

The most the account's queued and running hosted jobs can still cost.