workspace

person (a web session), key (an API key), system (the hub on its own), or agent — rows a plan's planner took, whichever credential it acted as.

Only rows at or after this instant (RFC 3339).

Only rows about resources owned by this handle (user or org). An unknown handle is an empty page, not a 404.

Page size.

Opaque cursor from the previous page's next_cursor.

A page of activity, newest first.

Missing or invalid credentials.

Request failed validation.

The caller's overview.

Missing or invalid credentials.

UI2 — the person this credential belongs to (a session's user, or a key's owner): what the workspace rail and the account button print, so a page needs no second call to getMe.

Executed runs (worker or modal) that are queued or running. Imported runs never run and plans are counted under plans.

Endpoints queued for a server, or running.

UI2 — sim-gate rollouts the caller can see, queued / running / total.

UI2 — the caller's live API keys, counted; null for a key credential.

W2 — the caller's own repos by kind, for the rail's My models and My datasets.

C3 — what the rail prints beside Campaigns.

A1 — the caller's agent sessions, and those waiting on a person (a spend above the session's pre-approved budget).

C4 — real-robot trials: how many candidates wait on a person's verdict (the Inbox's "needs your verdict" cards) and how many run.

The audit action (resource.verb, docs/API.md "Audit trail"), e.g. run.finish.

One sentence, safe to show verbatim — who did what to what.

The state this action left its resource in, when it set one (queued, running, succeeded, failed, canceled, pending, approved, issued, denied, stopped, refused, degraded, recovered, open, closed, active, done, handed_back, budget_exhausted, expired, rejected, revoked); null for actions that change no state.

USD the hub recorded for this action, set only where the cost was incurred: run.finish, coach.advice / coach.plan, plan.decision, endpoint.session_close. A closed session reads its CURRENT cost (the server's last report may re-price it).

With cost_usd: false when the hub charged nothing for it (a self-hosted worker, an unpriced model) — zero means "not charged by the hub", not "free".

Pending approval requests on devices the caller can see.

True for a signed-in session. An API key can never approve or deny (session-only), so for a key this is false and pending is what its person has to decide in the web app.

The ten newest, each with device, model and checks.

UI2 — every one the caller can see, whatever its status (for runs: imported and plan runs included; the same WHERE as an unfiltered listRuns). What the workspace rail prints beside the entry.

Active plans whose current approval request is still pending a person.

UI2 — every plan the caller can see, whatever its status.

Devices whose driver posted a signed event (a heartbeat, started, …) within online_window_s. A driver that is only polling for approvals writes nothing, so the hub cannot see it and counts it offline.

Devices running an approval right now (started, not stopped, inside its window).

Keys the caller has not revoked.

coach_usd + plan_usd + agent_usd.

Planner decisions metered in the window, rejected ones included (they were paid for).

A1 — agent sessions' model calls in the window (list price, from their ledger rows); the sandbox is not model spend.

A1 — agent model calls metered in the window.

Sessions and decisions metered at $0 because their model has no list price.

One sentence saying how the number was computed.

Sessions not yet ended.

Spend requests waiting on a person across those sessions — one Inbox item each.

The rail's "Agent, this month" box: the caller's own account's month-to-date agent spend against the free allowance.

AG1 — sessions asleep (nothing pending, nothing billing).

AG1 — decisions waiting on a person across the caller's sessions (plan, spend and shortlist; a handoff is the device consent request already counted in approvals). One Inbox item each; spend decisions are also pending_spend_requests.

AG1 — those decisions, newest first, at most ten (the Inbox's cards). Light: shortlist is left out (the candidates are read live and cost a gate-table read each — listAgentDecisions has them); approval and plan are included.

P2 — whether the hub's model backend (the agent, the Coach, the planner) can answer right now, as this API process last learned it: not_configured — this deployment has no model backend; unavailable — the provider's last answer refused the hub's own account (no credit, a billing hold, a bad key, overloaded), and no call has succeeded since; available — otherwise, including before any call. Best effort: each API process learns on its own. The web's agent composer reads it so it does not offer "free" model turns that cannot be served.

The newest trials that need a verdict — the Inbox's cards.

The resource's id (repo_…, run_…, dreq_…, …).

A display name: a repo's full name, a plan's task, a device's name, model → device for an approval, template · output repo for a run. A repo the caller can no longer read is never named in a row the caller sees only because they took the action.

The resource's owner (user or org), as recorded when the row was written.

The resource a page is reached through, for resources without a page of their own: the device of an approval request or approval, the endpoint of an endpoint session, the run a coach session read.

The first of next month, UTC.

none — no payment system exists, so the allowance is the cap and nothing beyond it can be spent.

One sentence saying how used_usd was computed.

The card's title, e.g. "Spend · R5 · yaw", "Shortlist for the robot — pick up to 2 of 3".

What would happen, in one sentence (hub-generated from the call or the round).

Why it waits — e.g. "Outside the plan you approved and over the $3.00 per-run limit, so it waits for you." (hub-generated).

What happens if it is denied or left to expire.

The agent's own words for what it proposes, quoted as written.

A spend — the session's compute budget when it was asked.

A spend — what would stay of that budget if the call ran to its cap ("After it, $3.90 of $10.00 stays").

A spend — the amount the second button offers as raise_budget_to ("Approve up to $8.40 for the rest of the session"): what is left of the session's budget before this call, at least the call's cap.

What the answer was, in words (approved up to $X, denied with the note, shortlisted 1600 and 1900, …).

What the decision is about. P1: an approved spend whose held call then created a run names that run (run_id) — and, for a round, campaign, round_n and round_id — once the call ran, so a page puts the run's card under the card that asked for it without reading the tool result.

The tool the model called (submit_training, rollout_in_sim, …).

The tool call's arguments as the model produced them; approving runs exactly these.

The hub's estimate of what the call will cost.

The most it can cost ("at most"): the run's own budget_usd or the tier rate x its wall-clock cap, a plan's budget, or the flat figure the hub uses where it prices nothing. This is what the per-run limit and the budgets are held to.

The session's pre-approved budget when the call was made.

Why it needs a person — the estimate against what is left of the budget.

rule (auto-approved), person (a web session) or key (the owner's API key).

AG1 — when a pending spend stops waiting: the end of the session's window when it was asked (AGENT_DECISION_TTL_S, 24 h). Past it the approval reads expired and nothing runs.

AG1 — the spend decision card that carries it.

The API path with every id filled in.

The web app's consent page for a device request (/inbox/requests/{id}) — the chat links there; it never approves.

owner/slug of a repo the call named or produced.

AG1 — the campaign's slug.

AG1 — the campaign round.

AG1 — a decision card of this session.

AG1 — a plan version of this session (not an M16 plan, which is plan_id).

AG1 — a checkpoint of run_id.

P1 — an AgentApproval of this session held the A1 way (a pre-AG1 session's spend with no decision card), answered through resolveAgentApproval.

How many rounds it lists.

2 — the founder's "at most two checkpoints to the real robot".

The agent's picks, pre-checked.

The agent's reason for its picks, quoted as written.

Round.control.separates — false puts the shortlist behind a person's override (C3b).

The device the consent requests will be filed for (the agent's choice, else the only registered device that accepts the model's contract); null — none does, and none will be filed.

The owner's devices that accept the model's contract.

The run window each consent request asks for.

E.g. "the 20-seed band scan on your picks first (13 cells × 20 seeds with video), not billed".

What the person shortlisted (decideRound), once answered.

/inbox/requests/{id} — where a person approves or denies it (M13).

workspace (the per-run limit and the session's own budget — since AG1 only a coach call is judged by it alone), campaign (C3b's campaign limits — no longer auto-approve a compute call since AG1, kept on old rows), plan (AG1: a compute call judged against the approved plan — inside it, it runs; outside it, a person decides whatever it costs; the sentence says which and, for a call outside it, how it compares with the per-run limit and the budget) or session_grant (AG1: inside a standing allowance a person granted with raise_budget_to).

AG1 — for a compute call, whether the approved plan names it.

AG1 — the approved plan the call was judged against.

AG1 — the plan round it is (its key), when it is one.

AG1 — the standing allowance a person granted, when one is in force.

AG1 — what was left of it before this call.

The budget the call had to fit in; null when only the per-run limit applies.

What that budget had already committed (approved caps) before this call.

committed_usd + cap_usd — the most the budget stands to spend if this call runs to its cap.

True when the call was inside the rule (auto-approved).

One sentence for the card, e.g. "Inside Omni walk's rules: $20.00 budget, $3.00 per run."

The agent's pick (pre-checked); the person changes it.

The round's locked gates at this step, measured.

Counted (locked) gates.

The hub's band rule at this step, cells passing (the 13-cell strip's number).

The cells that FAIL the band at this step (the "two cells that mattered").

Seeds behind the measurement (5 while training, 20 after the band scan).

The metrics line at this step (Train/mean_reward, else reward).

E.g. "laika-omni-c2-700 · 700 → 1600, 900 into R4".

What the run had cost when this checkpoint was published (published_at − claimed_at at its billed rate); null on an unpriced executor.

True when the round's band scan already measured the picks, so no new scan was queued.

render_check.matches once it finished.

Presigned 1-hour GETs of the rendered cell's views (side, front, feet), once it finished.

P1 — how long a render takes on this render's executor, measured on this hub (RolloutRenderRef.expected_s, docs/API.md "A render's expected duration"); null before one has finished there. A page's "N min left" is claimed_at + expected_s − now.

P1 — how many finished renders expected_s is the median of.

filed — a consent request exists (request_id); not_filed — reason says why (it failed the round's locked gates at the scan's seeds, no device accepts its contract, …).

The step's verdict by the round's locked gates after the scan.