Run and attempt states

A run is one execution of a task. An attempt is one try inside that run, so a run that retried twice has three attempts. For what they are, see runs and attempts.

Run statuses

Status	Means	Set when
`pending`	Waiting for a runner to pick it up	The run is created, or a stale run is requeued
`assigned`	A runner has claimed it	The runner’s heartbeat claims the run
`in_progress`	An attempt is executing	The runner opens its first attempt
`paused_approval`	Stopped at an approval gate	The task needs approval, or the agent asks mid-run
`finalized`	Finished, with an outcome	The runner reports a result, an approval is denied, or the control plane stops it
`cancelled`	Stopped deliberately	Cancelled from the run
`review`	Reserved	Nothing sets it today

The approval gate

paused_approval is the one status a run can enter and leave without finishing.

A run that needs approval is created already paused, before any runner sees it. A run that hits a gate mid-flight is paused where it stands.
The run remembers the status it paused from.
Approving returns the run to that remembered status, so a run paused before it was claimed goes back to pending and one paused mid-execution resumes.
Denying finalizes the run with the outcome inconclusive and the reason approval_denied, fails the running attempt, and frees the runner.

Terminal outcomes

A finalized run carries exactly one outcome.

Outcome	Means
`accepted`	The work was accepted. This is the one that lets the task advance
`rejected`	The work was produced and rejected
`inconclusive`	No usable answer. Denied, abandoned, or stopped

A run that stopped at a limit with real work on a branch is inconclusive with the reason partial, and it is never accepted on its own: the decision goes to a person. See when a run reaches a limit.

Alongside it, a run may carry a reason for finishing the way it did.

The reasons a runner may report are a closed list. A runner that reports anything else is refused and nothing is written, so a reason recorded on a run is always one of these. Two of them, approval_denied and wall_clock_exceeded, the platform also writes itself when it stops a run rather than waiting for the runner to report.

Reason	Means
`passed`	The work was produced and the review accepted it
`partial`	The run stopped at a cap with work worth keeping; it is never accepted
`cap_exceeded`	The run used every attempt it was allowed without reaching an accepted result
`wall_clock_exceeded`	The run passed its wall-clock limit and was stopped
`budget_exceeded`	The run reached the spend ceiling resolved for its task type
`review_unparseable`	The review of the work came back in a shape that could not be read as a verdict
`redteam_unparseable`	The red team’s report came back in a shape that could not be read as a verdict
`checks_disagree`	The review and the task’s own checks reached opposite verdicts
`awaiting_setup`	The run needs a value from a person and raised a setup task asking for it
`awaiting_assist`	The run hit a blocker only a person can clear and raised a task asking for it
`awaiting_approval`	The run reached an approval gate and nobody answered while it waited
`approval_denied`	An approval gate was denied
`toolchain_unavailable`	The project’s toolchain could not be prepared in a fresh checkout, so nothing ran
`containment_unavailable`	The runner could not establish the boundary it runs agents inside, so nothing ran
`no_adapter`	The runner has no coding agent installed that can execute this run
`no_agent_credential`	The coding agent had no credential to sign in with
`no_run_env`	The project environment the run asked for could not be assembled
`no_mcp_credential`	A tool server attached to the run had no usable stored credential
`invalid_metadata`	The run was dispatched without something the runner needs before it can start
`model_family_mismatch`	The model asked for belongs to a different provider than the agent running it
`runner_error`	The runner itself failed
`chat_complete`	A chat turn finished normally
`chat_failed`	A chat turn failed
`chat_malformed_request`	A chat turn arrived in a shape the runner could not read

The platform writes a few reasons of its own, none of which a runner may report:

Reason	Written when
`abandoned`	The assigned runner went stale and the run was out of attempts
`admin_forced`	A platform administrator stopped the run by hand
`canary_echo`	The run was the platform’s own end-to-end health probe rather than your work
`chat_deadline_exceeded`	A huddle chat turn did not come back in time
`eva_chat_deadline_exceeded`	An Eva chat turn did not come back in time
`managed_queue_timeout`	No managed runner claimed the chat run before it gave up waiting
`completion_deadline_exceeded`	A chat run passed its own deadline while a runner held it

Attempt states

An attempt carries a status and a phase. The status says whether it is alive; the phase says what it is doing.

Status	Means
`running`	Executing now
`completed`	Finished and reported a result
`failed`	Finished without one
`cancelled`	Stopped before it finished

Phase	Means
`planning`	Working out what to do
`executing`	Doing it
`awaiting_review`	Waiting for its work to be evaluated
`checks`	Reserved. The runner is executing the task’s checks with no model in the loop
`red_team`	Reserved. A separate attempt is trying to make the implementation fail
`done`	Finished

When a run retries

Every run carries an attempt ceiling, from the budget resolved for its task type. A run whose runner goes quiet is requeued to pending and tried again while attempts remain. Once they run out, the run finalizes inconclusive with the reason abandoned instead of waiting forever.

The current values are on limits.

Next steps

Runs and attempts: the same machine, explained rather than tabulated.
Task states: what the task does while its run moves.
The approvals queue: deciding a gate.