Job and workflow statuses
- Synopsis
- Full Details
In briefEvery job and every workflow instance carries exactly one status. A job's status says which gate it is at, or how it ended, and decides which of its 11 lifecycle actions it accepts. A workflow instance's status does the same for its own actions. This page lists every status, its family, and the actions each accepts.
WhereStatuses show on Operations › Processes: in the Status column of Job View and Workflow View, on the cards of the run diagram, and in each view's Status(s) filter as status groups. This page names each job status as the Job History report's Job Termination Status filter lists it (for example Waiting: Machine); the status badge on Processes spells some of them differently (Wait Machine) — see How each screen spells a status. A job's actions are in its row menu and on its detail panel's Status Update tab.
When
- A job is waiting and you want to know what it is waiting for.
- An action is disabled and you want to know why.
- You need to know whether a status is final, or whether dependents have been released.
- You want to run more work on a workflow instance that has completed.
Use something else when you need to decide what to do about a status: see the Operator response guide.
How
- Read the job's status on Processes.
- Find it under Job statuses to see what it means and which gate it is at.
- Check Which actions a job status accepts, then take the action from the row menu or the Status Update tab.
For the full steps, see Job statuses and actions.
- The gates are checked in a fixed order, so a waiting status names the first thing still unmet.
- A (Pending) status is not finished: dependents are released only when it settles.
- Under Review is not final. It releases dependents waiting for a failure, but the workflow does not complete while a job holds it.
- Skip in a live workflow is deferred: the job reads Job to Be Skipped until its turn comes.
- Holding a workflow holds every sub-schedule beneath it, at any depth.
- A workflow with failed jobs still completes as Completed. Workflow View marks it Completed with errors, with a red count of its failed jobs.
- A job is never sent to an agent that cannot take it. It waits in Waiting: Machine, or a force-started job in Wait to Start (Forced), until its agent or a backup agent can, and its Status History says why it is waiting.
- A job whose work no agent picks up does not wait for ever: it ends Initialization Error, or Missed Start Time when its Latest Start passes.
- A job sent to its agent reads Start Attempted until the agent confirms the start, and only then Running. After about five minutes without a confirmation it reads Still Attempting Start; it is flagged, not failed.
- Each run, retry, restart and force start is checked against late deadlines measured from its own start, so a job you restart after its deadline has passed is not reported late at once.
- Mark Finished OK and Mark Failed do not stop a running job. Kill it first if the work has to stop.
- Cancel is not accepted on a running job. For a running job, use Kill.
- Kill on a legacy job is refused when its agent's Allow Kill is off — the default on SAP R/3 and CRM agents.
- A UNIX Command, SAP R/3 Job, SAP BW Process Chain, z/OS Batch Job or z/OS Started Task restarted on a step keeps that step, through failure retries, until it finishes OK. Restart it From the beginning to clear it.
- Hold, Release and Start on a completed workflow reopen it. Nothing runs until you restart a job on it.
- A running container job accepts no action, not even Kill: act on the jobs in its nested workflow instead.
Task walkthrough: Job statuses and actions. This page is the full configuration and troubleshooting reference.
Every job carries exactly one status, and that status decides two things: what the job is doing right now, and which actions you are allowed to take against it. Statuses fall into families — held, waiting, running, pending-term, and terminal — and a job moves between them in a fixed order. This page lists every status, the family it belongs to, and the actions each one accepts. The status names here are the authoritative set.
- Status Order
- Job Statuses
- Late to Start and Late to Finish
- Pending and Terminal
- Workflow Statuses
- Status Filters
- Job Actions
- Workflow Actions
Status Order
The order a job moves through
A job does not sit in one "waiting" state. It passes down a chain of gates, and its status tells you which gate it is at right now. Each gate releases it to the next one; the job only starts once it has cleared them all.
Reading it:
- The order is fixed. A job at Waiting: Resource Dependency has already satisfied its start time, its predecessors and its thresholds. That is why the status is a useful diagnosis on its own — it names the first thing still unmet.
- Waiting: Machine is always checked, even when a job has no dependencies at all.
- A conflict is re-checked at the last moment. A job cleared for dependencies can still be diverted to Waiting: Job Conflict just before dispatch, if the job it must not run alongside started in the meantime. It returns to the queue once that job finishes.
- Cancel and skip can happen from any waiting gate — those arrows are left off to keep the picture readable.
- Running means the agent has started it. A job sent to its agent reads Start Attempted until the agent confirms the job really started — see A job is Running only once its agent confirms it.
- A (Pending) status is not finished. The job has stopped, but completion processing is still running and dependents are not released yet.
Job Statuses
How each screen spells a status
This page names each job status as the Job History report's Job Termination Status filter
lists it. Processes spells a status differently: its status badge, used in the Status column,
on the run diagram's cards and throughout a job's detail panel, turns the stored status into words
(Wait Start Time rather than Waiting: Start Time). The Status(s) filter on Processes
offers status groups instead — see the Status Filters tab. A report's results list the stored
value itself, such as FINISHED_OK.
| Report filter (this page) | Processes badge |
|---|---|
| Job to Be Skipped | Job To Be Skipped |
| Late to Start | Late To Start |
| Pre-run Failed | Prerun Failed |
| Waiting: Start Time | Wait Start Time |
| Waiting: Job Dependency | Wait Job Dependency |
| Waiting: Threshold Dependency | Wait Threshold Dependency |
| Waiting: Resource Dependency | Wait Resource Dependency |
| Waiting: Expression Dependency | Wait Expression Dependency |
| Waiting: Job Conflict | Wait Job Conflict |
| Waiting: Machine | Wait Machine |
| Wait to Start / Wait to Start (Forced) | Wait To Start / Wait To Start Forced |
| Attempting to Start | Attempt To Start |
| Pre-run Active | Prerun Active |
| Running | Job Running |
| Running (To Be Terminated) | Job Running To Be Terminated |
| Late to Finish | Late To Finish |
| A (Pending) status, such as Finished OK (Pending) | The status followed by ; Processing Events, such as Finished OK; Processing Events |
Every other job status reads the same in both places, Finished OK and Marked Finished OK included. Earlier builds spelled those two Finished Ok and Marked Finished Ok on the badge, and ended a pending status with Pending Term, as in Finished Ok Pending Term.
A workflow's badge on Processes capitalizes each word, so Wait to Start and Started by User read Wait To Start and Started By User.
Held
| Status | Meaning |
|---|---|
| On Hold | Held; won't run until released. |
Waiting
| Status | Meaning |
|---|---|
| Released | Released and eligible to proceed. |
| Waiting: Start Time | Waiting for its scheduled start time — or for its next attempt, if it failed with failure-retry budget left, or for its next attempt after a failed prerun. In the retry case the job holds the failed attempt's exit code, and its dependents are still waiting. |
| Waiting: Job Dependency | Waiting on a predecessor job. |
| Waiting: Threshold Dependency | Waiting on a threshold value. |
| Waiting: Resource Dependency | Waiting until the job can have the resource it needs — enough free units, or the whole resource for a Use All dependency. Nothing is reserved here; the units are taken when the job is dispatched. A job that passes this gate and is then refused its units comes back to this status, naming the resource. See Thresholds and resources. |
| Waiting: Expression Dependency | Waiting on an expression dependency to render True. The expression is re-asked about once a second; False is the normal state of a gate that is not open yet, and an expression that cannot be evaluated moves the job to On Hold with the cause recorded as its termination description. |
| Waiting: Job Conflict | Waiting because of a conflict with another job. |
| Waiting: Machine | Waiting for an agent/machine to be available. A specific-agent job holds here while its target agent cannot take new work: it is anything but Online (Offline, or Unknown because its relay was lost or cannot see the machine), it is marked (Marked Offline, Marked Draining), or it is a legacy agent whose relay has not reported it for more than five minutes, even though it still reads Online. The job proceeds once the agent can take it, or, if it has backup agents, as soon as one of them can. The job also holds when its agent cannot be found (deleted, or not visible to you) or its status cannot be checked: a job is never sent to an agent on a guess. A job on a Universal Agent pool holds here while the pool has agents and none of them is Online and unmarked; a pool with no agents of its own lets the job through. A legacy-group job holds here until the group has a member dispatch could route to, or while the group's members cannot be read — see When a legacy group has no dispatch target. Each time the reason a job is held changes, its Status History gets an Agent Availability Hold entry whose details say why, for example Waiting for agent <agent>. The agent is not available. or Waiting for agent pool <pool>. No agent in the pool is available. Earlier builds let a specific-agent job through when its agent could not be looked up, and never checked a pool job's agents here. |
| Wait to Start / Wait to Start (Forced) | Queued to start (forced = via Force Start, or a z/OS Tracked Job the agent reported as started). Jobs are taken from here in priority order, highest first. A job refused its resource units at this point returns to Waiting: Resource Dependency rather than waiting here. A forced start does not take resource units at all. Once the platform has handed a job to its agent, the job moves on to Start Attempted even if part of recording that hand-off fails. Earlier builds could leave such a job here while it ran, and start it a second time. A job the agent forced — a tracked job, or a queued job the agent told to start — goes first, ahead of other forced jobs, and is sent even when its agent is Marked Draining or has no free slot, because the agent is already running or holding it; it waits here while the agent is Offline or Marked Offline. A forced start by an operator keeps every agent check. The agent is checked again just before the job is sent. If by then neither the job's agent nor any of its backup agents can take it, by the same rules as Waiting: Machine, nothing is sent: a Wait to Start job goes back to Waiting: Machine, and a Wait to Start (Forced) or Late to Start job stays in its status and is sent as soon as an agent can take it. A forced job held this way never becomes Missed Start Time. If you change the agent of a job waiting in Wait to Start, it goes back to Waiting: Machine and waits for the new agent. Earlier builds sent the job to its agent anyway, or to the primary when no backup could take it, and it sat in Running with no agent to pick it up. |
| Late to Start | Past its Late to Start Offset, not yet started. Advisory — the job can still start, and this is a dispatch status, so a job here has already cleared every gate. A job still waiting on a gate is badged instead of moved here — see Late to Start and Late to Finish are raised. |
| Job to Be Skipped | Marked to be skipped but not yet resolved — a deferred skip. Reached either by an operator's Skip in a live workflow, or at build time from a frequency whose Build Status is To Be Skipped. No end time, and its dependents are not released yet. The engine resolves it to terminal Skipped in sequence once the job's own gates are satisfied. See the Skip note under Which actions a job status accepts. |
| Pre-run Failed | The prerun command failed on a legacy LSAM agent. The job has not run, and it is re-attempted automatically rather than ending here: it passes through this status and waits in Waiting: Start Time for the re-attempt — see A failed prerun is re-attempted, not failed. |
A failed prerun is re-attempted, not failed
A legacy LSAM job can carry a prerun command that runs on the agent before the job itself. When that prerun fails, the job moves to Pre-run Failed, which fires the Job Prerun Failed event trigger. It is then parked straight away in Waiting: Start Time and started again from the beginning after about three minutes.
This is what a gate-style prerun is for: a prerun that tests whether the job's preconditions are met holds the job until they are, instead of failing it on the first miss.
| What is affected | What happens |
|---|---|
| The job's own outcome | Not decided. The prerun failed, so the job never ran, and the prerun's exit code is never judged by the job's exit criteria |
| Dependents | Not released. Pre-run Failed is a waiting status, so nothing downstream — including a dependency whose Condition is Failed — reacts to it |
| How many re-attempts | Unlimited. The job keeps re-attempting until the prerun succeeds, or until an operator steps in |
| Failure retries | Untouched. A failed prerun does not count against the job's failure retry budget, because it is not a failed attempt of the job |
| The reason | The agent's message is kept as the job's termination description while it waits, so you can see why the prerun failed |
- A Kill issued while the prerun is running ends the job Failed, as a kill always does.
- If the job's latest start deadline passes while it is parked between attempts, it ends Missed Start Time, as in Classic. The job never ran, so nothing downstream is released — not even a dependency waiting for Failed — and the prerun's message is cleared from the job's termination description.
While it is parked it reads Waiting: Start Time, so an operator can also Hold, Cancel, Skip or Force Start it as any waiting job — see Which actions a job status accepts.
Running
| Status | Meaning |
|---|---|
| Attempting to Start | The platform is handing the job's work to its agent. |
| Start Attempted | The job's work has been sent, and its agent has not yet confirmed that the job started. The job's start time is set here. See A job is Running only once its agent confirms it. |
| Still Attempting Start | The job has been at Start Attempted for about five minutes with no confirmation from its agent. Its termination description reads Start Delay Detected. The job is not failed for waiting: it moves on to Running as soon as the agent confirms the start, or stays here until you act on it. |
| Pre-run Active | A legacy LSAM job whose agent reports that it is running the job's prerun, on any legacy platform. The job moves here from Start Attempted, Still Attempting Start or Running, and on to Running when the agent reports the job itself running. One Job Running notification is sent per run: a job that was already Running before its prerun sends no second one. It is still a running job: Late to Finish and Max Run Time are checked against it as on Running, and it accepts Kill, Mark Finished OK and Mark Failed. A job already in Late to Finish or Running (To Be Terminated) is not moved here. Needs a current relay; on an older one the job reads Running throughout. |
| Running | Running: the job's agent has confirmed that the job started. |
| Running (To Be Terminated) | Running, marked to be terminated. The job holds here until the agent stops the process and reports its outcome — see Killing a job on a legacy (LSAM) agent. |
| Late to Finish | Running past its Late to Finish Offset. The job is not stopped, it keeps its concurrency slot, and it still earns whatever terminal status it would have earned — see Late to Start and Late to Finish are raised. |
A job is Running only once its agent confirms it
A job sent to its agent reads Start Attempted, not Running, until the agent reports that the job really started. Each kind of agent confirms at the point where the job is known to be going:
| The job runs on | It reads Running once |
|---|---|
| A legacy (LSAM) agent, through a relay | The agent first reports the job running, or running its prerun (the job then reads Pre-run Active) |
| OpCon MFT | OpCon MFT accepts the transfer and returns its run |
| OpCon RPA | OpCon RPA first reports the job running |
| EASE | EASE reports that the remote job has started |
| A Universal Agent | The job's process has started on the machine, after its plugin was downloaded and checked. A File Wait job is running once the wait begins |
| No agent (a Workflow Container job, for example) | It starts, as before: it goes straight to Running |
What this changes for you:
- Running means running. A job whose relay is disconnected, or whose agent is down, reads Start Attempted and then Still Attempting Start, not Running. Earlier builds moved every job to Running as soon as its work was sent, so a job no agent had could read Running for days.
- A stalled start is flagged, not failed. About five minutes after it was sent, a job still at Start Attempted moves to Still Attempting Start, with the termination description Start Delay Detected. That move fires the job's Still Attempting Start job events and the Job Still Attempting to Start notification trigger, which never fired in earlier builds. The five minutes is the default; each Continuum deployment sets its own.
- The platform keeps asking. For a job at Still Attempting Start, Continuum asks about the job's work once every five minutes. If, on two of those checks, there is no record of the work at all, the job ends Failed with the termination description Job not found after dispatch, and its failure retries apply. Nothing else ends it on time: a job whose agent stays silent waits for the agent or for you. The rules in A job no agent picks up is ended still apply to work no agent ever took.
- You can resolve it yourself. Mark Finished OK, Mark Failed and Kill are accepted at Start Attempted and Still Attempting Start. A confirmation that arrives after you mark the job does not revive it.
- A job that finishes fast still shows that it ran. A job whose agent reports it finished before it was seen running passes through Running in its Status History, and sends its Job Running notification, when the agent confirmed the start. A job that never started — its plugin failed to download, say — goes straight to its result with no Job Running notification.
- Job Running is sent once per run, on the confirmation. Job Submitted is still sent once, when the job is handed to its agent.
- The start time is when the job was sent. A job's start time, and so its Max Run Time, counts from Start Attempted, not from the confirmation. Max Run Time and Late to Finish are checked at Start Attempted and Still Attempting Start as at Running, and both statuses count against the platform's dispatch limit.
- Older relays and agents. A relay or Universal Agent from before this change does not send the confirmation. Its jobs read Start Attempted until the agent takes the work, then Running, as before.
Exceeding Max Run Time is not a status
A job that runs past its Max Run Time is labelled, not transitioned. There is no Exceeded Max Run Time status: the job still reads Running while it runs, then earns whatever terminal status it would have earned anyway — including Finished OK.
What you see instead is an Exceeded Max Run Time badge beside the status, and it stays visible after the job completes. That is the point of it being separate: a job that overran and then finished OK is exactly the case the status alone cannot show. The overrun is reported once per run, and the job is not stopped — see Exceeding Max Run Time for how to have it killed instead.
A job always reaches a terminal status
Running is not somewhere a job can stay for ever. Three ways a run could end short of reporting an outcome — it was cancelled underneath the platform, it timed out waiting to be picked up, or it could not be delivered to an agent at all — used to leave the job reading Running indefinitely, with nothing to do but mark it by hand. All three now end the job Failed, the same place a kill or a relay failure puts it.
A job whose work was cancelled, timed out or undeliverable before an agent ever took it is not eligible for a failure retry, even with retry budget left. It ran nothing, so there is nothing to retry — and for a cancel, a retry would quietly undo an operator's decision, which is the opposite of what was asked for. A job that did run and then failed retries as normal.
A job no agent picks up is ended
A job reads Attempting to Start, and then Start Attempted, as soon as its work is sent to an agent — before any agent has picked it up. If no agent ever does (its agent, relay or pool is gone, say), the job used to stay there indefinitely. Continuum now checks every minute for a job in Attempting to Start, Start Attempted, Still Attempting Start, Running or Late to Finish whose work has been waiting at least a minute with no agent taking it, and ends it on the first of these that applies:
| What happened | The job ends | Termination |
|---|---|---|
| It was sent before its Latest Start and that time has now passed | Missed Start Time | None |
| No agent that could take it has been available for 10 minutes | Initialization Error | No agent claimed the job: agent <agent> has been unavailable for 10 minutes (or no agent in group <group> / no agent in pool <pool> has been available) |
| No agent has taken it 24 hours after it was sent | Initialization Error | No agent claimed the job within 24 hours |
The 10 minutes and 24 hours are the defaults; each Continuum deployment sets its own.
- Available means the job's agent or one of its backup agents is online, a legacy agent group has a member that can take work, or a pool has an agent online. A pool whose agents are online but busy counts as available, so its jobs are ended only by the Latest Start and 24-hour rules.
- A job that was ended never ran. Its work is withdrawn first, and that succeeds only while no agent has taken it. If an agent takes it in the meantime, the job is left to run.
- A late Force Start is not undone. A job you Force Start after its Latest Start has passed is not ended Missed Start Time for it; the other two rules still apply.
- The 10-minute count is kept by the running platform, so it can start over after a restart.
A long outage no longer fails a job that is still running. When a legacy LSAM agent's connection drops, the relay holds the job while it waits for the agent to come back. That hold used to give up after 30 minutes and fail the job — even though the job was still running on the agent, whose eventual completion was then discarded. The hold now lasts up to seven days, so an outage has to be genuinely long before a running job is written off, and the job's real outcome is the one you see. Meanwhile a job still held after a transient error is re-probed within about 24 minutes regardless of how long the hold is allowed to last. A job sent while its machine was dropping is held the same way from the start. When a hold runs out, a start the relay had queued and never delivered to the machine is withdrawn, so the job does not run late when the machine returns.
Late to Start and Late to Finish
Late to Start and Late to Finish are raised
A job that misses a late deadline is now reported. In earlier builds nothing ever reached Late to Start or Late to Finish: the engine compared a running job against two fields no build path ever filled in, so every check was unreachable. The Late to Start Offset and Late to Finish Offset you set on a frequency were saved, carried onto the job — and never acted on, so the Job Late to Start and Job Late to Finish event triggers and job events never fired either.
Check any job you set a late offset on before this release. Its configuration was correct all along; nothing was watching it.
Which deadline, measured from where
A late deadline is this run's scheduled start plus the offset, so each run of a job is checked against its own deadline. Late to Finish is measured from the scheduled start too, not from when the job actually started.
| The run | What the deadline is measured from |
|---|---|
| First run | The planned schedule start plus the job's Start Offset. A job with a 00:00 start offset measures from the planned schedule start itself |
| First run, relative start offset | The workflow's actual start plus the offset. This is the only case that follows the real start — until the workflow starts, both deadlines are placeholders and neither is enforced |
| Recurring run | That run's scheduled restart time, or the restart moment for a job that restarts as soon as possible |
| Failure retry | The parked job's next retry time, or the failure moment when there is no retry interval |
| Pre-run retry | The time the job re-attempts its failed prerun, so a job parked in Pre-run Failed is not reported late against the attempt that failed |
| Restart | The moment you restart the job. On the first run, a restart before the planned start measures from the planned start instead, so the job is not judged early. A restart on hold is measured the same way |
| Force Start | The moment you force-start the job, since a forced job starts at once. A force start the workflow holds back until it can process jobs is measured like a restart. Forcing a job already in Wait to Start (Forced) does not re-measure |
| A job inside a container that recurred or retried | The later of the job's own first-run scheduled start and the container's next run start — see below |
An operator who edits a first run's planned start moves both deadlines with it: the edit is treated as moving that run's scheduled start. A late offset you change on the job instance is measured from the attempt its current deadlines belong to — a retry, restart or recurring run included — not from the first run's planned start. The offset is added as wall-clock time, like Latest Start, so a daylight-saving change between the start and the deadline does not shift it by an hour.
A nested job gets fresh deadlines for the container's next run. When a Workflow Container recurs or is failure-retried, the jobs its nested workflow resets are re-measured for the run that is about to happen, instead of keeping the deadlines of the container's first run. Without that, a nested job was reported late on every run after the first — not because it was slow, but because its deadline belonged to a run that had already finished.
Taking the later of the two starts is what makes a job's own place in the day survive the reset: a nested job scheduled to start well after the container does keeps that later start as its base, rather than having the container's restart time pull its deadline earlier.
A nested job with a relative start offset is the exception, as it is for a first run: its deadlines wait for the nested workflow's actual start and are measured from there.
A late time set as a fixed time moves with the run too. The editors always set a late deadline as an offset, but an edit through the API can set Late to Start or Late to Finish as a fixed time instead. When such a job recurs, is failure-retried, re-attempts its prerun, or is restarted or force-started, or the container it sits in recurs or is retried, that time moves forward by the gap between the two runs' starts, so it keeps the same distance from the run it belongs to. An edit that moves a recurring job's next run time moves it by the same gap. A later run is no longer judged against the first run's clock time. The gap is counted in wall-clock time, so a daylight-saving change between the runs does not shift it. This applies to the two late deadlines only: a nested job's Latest Start set as a fixed time is left where it is.
A waiting job is badged, not moved
Late to Start is a dispatch status — a job in it has cleared every gate and is about to start. So a job that is still waiting on something cannot be moved there without starting it early. What happens instead depends on what the job is waiting for:
| Where the job is | What happens at the deadline |
|---|---|
| Queued to start (Wait to Start) or waiting on a conflict (Waiting: Job Conflict) | Moves to Late to Start |
| Waiting on a dependency, threshold, resource, expression or machine | Keeps its status and gains a Late to Start badge beside it, so its gates still apply |
| Waiting for its scheduled start time | Neither. The deadline is measured from that start time, so it has not arrived yet |
| Running or Pre-run Active | Moves to Late to Finish |
The badge does the same reporting work the status does: it fires the job's Late to Start events and matches the Job Late to Start notification trigger. It is raised once per run — a badged job is never moved to Late to Start later, and a job that reached the status is not badged on top, so you are told once either way. The mark is cleared when a new run begins: at dispatch, on a restart or force start, and on a recurring reset.
Giving a job more time clears the mark. Edit a job that has not started yet and move its Late
to Start time past now, and the mark comes off — the job stops reading as late, because by its own
new deadline it is not. Clearing its Late to Start Offset back to 00:00 removes the deadline and
takes the mark off too. This covers a job that is On Hold, Released or waiting for its
start time as well as one still queued, which matters because a held job comes back through the
waterfall carrying whatever mark it had, and a job already marked is never re-checked. Without the
clear, one hold would make the mark permanent for the rest of the run.
The status comes off too. A job already in a late status is moved back on the platform's next pass once its deadline no longer holds:
| The job | The edit | It moves to |
|---|---|---|
| Late to Start | Its Late to Start time cleared, or moved past now | Wait to Start, unless its Latest Start has passed too, in which case it is ended as Missed Start Time |
| Late to Finish | Its Late to Finish time cleared, or moved past now | Running, or Start Attempted if its agent has not yet confirmed the start |
The move is recorded in the job's Status History, but no new status notification is published for it, so a Job Running notification is not sent a second time. The one exception is a job whose agent confirmed its start while it read Late to Finish: its move to Running is that run's first, and sends Job Running. Earlier builds took the mark off and left the job in Late to Start or Late to Finish for the rest of its run.
Two details worth knowing:
- Moving the deadline back does not re-fire anything. The events and the notification trigger already fired, once, for that run. Clearing the mark lets the job be checked again, and the deadline it is checked against is the new one.
- An edit that lands while a late sweep is in flight wins. If a sweep decided the job was late and your edit moved the deadline past it before the sweep was recorded, the sweep's mark is dropped rather than applied — so the job is not briefly marked late against a deadline it no longer has.
A badged job keeps its wait status, so anything that reads the raw status — the Job History report, for instance — lists it under what it is waiting for, not as Late to Start. The operator dashboard's Late to Start count does include badged jobs, so the count and the status list can legitimately differ.
What a late job does not lose
- Late to Start is advisory. The job can still start, and a workflow hold does not suspend it — unlike the Latest Start deadline, which a hold does suspend.
- A job running late still counts as running. Late to Finish is counted against the platform's dispatch limit alongside Start Attempted, Still Attempting Start and Running, so a job that overruns does not free capacity for another job while it is still going.
- Missed Latest Start wins. If both a late deadline and the Latest Start deadline have passed on the same pass, the job goes terminal Missed Start Time rather than being reported late.
- Both statuses are non-terminal. A job in Late to Start still dispatches; a job in Late to Finish still completes with whatever outcome it earns.
Pending and Terminal
Pending-term (transitional)
Finished OK (Pending) · Failed (Pending) · Marked Finished OK (Pending) · Marked Failed (Pending) · Skipped (Pending) · Under Review (Pending) · Fixed (Pending) — completed, completion processing in progress; dependents not yet released.
A job passes through one of these for about a second after you set its status by hand, as well as when it completes on its own. While it's there:
- The Status Update tab reads This job's status update is still being processed. Actions will refresh automatically. rather than saying no status changes are available — there genuinely are no actions yet, but the job isn't finished either.
- The tab's action buttons, including Restart, are disabled while the panel is refreshing, so you can't fire an action against a status the platform has already moved past.
- The panel and the Jobs grid refresh themselves every couple of seconds until the status settles, then drop back to their normal cadence. Earlier builds waited for the ordinary refresh interval or a manual reload, which is why a marked job could appear stuck on a (Pending) status.
Marking a job and then immediately marking it again — Mark Finished OK followed straight away by Mark Failed — means the second action arrives while the first is still in pending-term. Wait for the status to settle; the actions reappear on their own.
Terminal
| Status | Meaning | Category |
|---|---|---|
| Finished OK / Marked Finished OK | Completed OK (marked = set by a user) | Success |
| Fixed | Marked fixed; treated as resolved | Success |
| Failed / Marked Failed | Failed (marked = set by a user) | Failure |
| Initialization Error | Failed to initialize, or no agent picked up its work — see A job no agent picks up is ended | Failure |
| Missed Start Time | Did not start by its Latest Start Offset — including a job sent to its agent before then that no agent picked up in time (see A job no agent picks up is ended). The deadline is measured from the job's schedule date, not from today, and it applies to a recurring job parked between runs as well — reaching it retires the rest of that job's cycle. Two exceptions: a job waiting for a failure retry ran already, so passing the deadline there ends Failed instead (a job waiting to re-attempt a failed prerun never ran, and ends Missed Start Time); and a job in a held workflow is not ended at all while the hold is on. The deadline is checked while the job waits for its start time, waits at a dependency, threshold, resource, expression or machine gate, waits on a conflict, is queued to start, or is Late to Start. A job in Wait to Start (Forced) is not checked. See also Scheduling and the run, Failure retries and Holding a workflow suspends the deadline | Failure |
| Cancelled | Cancelled | — |
| Skipped | Skipped | — |
Under review (not terminal)
| Status | Meaning |
|---|---|
| Under Review | A failed job an operator has flagged for review with Under Review. |
Under Review is not a final status, and it has two effects worth knowing:
- Dependents that wait for a failure are released. A dependent whose Condition is Failed or Any treats an under-review predecessor as failed, so recovery work can start. A dependent whose Condition is Finished OK keeps waiting. See Dependencies.
- The workflow does not complete. A workflow completes only when every job is in a terminal status, so one holding an Under Review job stays In Process. To finish it, resolve the job — Mark Fixed, Restart, Skip, Cancel, Mark Finished OK or Mark Failed — or Close the workflow, which accepts under-review jobs.
Lost in Failover (not terminal)
| Status | Meaning |
|---|---|
| Lost in Failover | A relay could not confirm a job's result after a failover or a restart: a legacy machine, or the OpCon MFT, OpCon RPA or EASE agent, did not know the job, or the job's start had been sent without its run id coming back. Or the Universal Agent running the job stopped responding — see When a Universal Agent stops responding. |
The job is not marked Failed, because it may have succeeded, and it is not counted as running to completion either. It reads Lost in Failover in Processes and in reports, with a warning badge and its own entry in the Status(s) filter. Its Agent Message tells you to check the job on its machine, then mark it finished or failed.
- Dependents are held. The job releases nothing until its outcome is known.
- A real result still replaces it. If the machine later reports the job's result, the job moves on as it would have. The job's detail keeps refreshing while it reads Lost in Failover, so a late result and its output appear without reloading the page.
- You decide the outcome. The only actions it accepts are Mark Finished OK and Mark Failed. Either releases dependents as it does for any other job. It cannot be restarted, skipped or cancelled.
When a Universal Agent stops responding
A Universal Agent that stops heartbeating goes Offline after about 90 seconds. Its work is then handled by what it had reached:
- Work it had taken but not started goes back on its queue, so it can be picked up again. Only work taken in the last 11½ minutes or so is put back: older work may be a job you have already closed, so it is never run again, and is treated as in flight instead.
- Work it had taken that you had asked to Kill is not sent again. The job ends Failed.
- Work in flight — running, or taken longer ago — is shown as Lost in Failover once the agent has been silent for about 10 minutes more. Its Agent Message reads The agent running this job stopped responding, so its result is unknown. Check the job on its machine, then mark it finished or failed., followed by (Agent lost: AGENT_LOST). If the agent comes back and reports the job's real result, that result replaces it.
Workflow Statuses
| Status | Meaning |
|---|---|
| Building | Listed in the status set and the Building filter group, but the build does not put an instance in it: a new instance starts as Wait to Start, as On Hold when it is built on hold, or as Wait Container Job for a sub-schedule. |
| Wait to Start | Built, waiting to start. |
| Wait Container Job | Waiting on a container (nested workflow) job. |
| In Process | Running. |
| On Hold / Parent Hold | Held by an operator / held because an ancestor workflow is held. |
| Started by User | Started manually. |
| Completed / Cancelled | Terminal. |
| Unknown | Indeterminate. |
A failed job does not change its workflow's status: a workflow completes once every job is in a
terminal status, failed or not. The Workflow View on Processes shows the difference beside
the status instead: a red "N failed" indicator when any job is Failed, Marked Failed,
Initialization Error or Under Review (or the pending form of one of these), and a red
Completed with errors in place of Completed when a completed workflow has any. See
Workflows with failed jobs.
Holding a nested hierarchy
Holding a workflow holds everything beneath it, however deep the nesting goes. Every sub-schedule below a held workflow reads Parent Hold, and none of their jobs is dispatched.
This used to reach exactly one level. A hold on a parent held its immediate sub-schedules, but a sub-schedule of those kept running — so on a three-level design, holding the top stopped the middle and left the bottom working. Each workflow now looks up its whole chain of ancestors rather than at its immediate parent alone, so the nearest held ancestor at any depth puts it in Parent Hold.
Four consequences are worth knowing:
- A release resumes the whole subtree. Parent Hold is derived from the ancestor chain, not stored as a decision, so it is re-evaluated continuously — releasing the ancestor lets everything below it resume without acting on each level.
- A hold an operator placed directly is not overwritten. A workflow you set to On Hold stays On Hold even while an ancestor is also held, and only a Release on it clears it. It does not quietly become Parent Hold and get released along with the ancestor.
- Held workflows still finish work already in flight. A hold stops new jobs starting; it does not stop a workflow completing. That matters most for a nested run: a held sub-schedule that could not complete would never resolve its container job, and the whole chain above it would wedge behind it.
- Jobs are blocked for the sweep in which the hold lands. A descendant reads its old status for a moment after an ancestor is held, so dispatch checks the ancestor chain itself rather than trusting the descendant's status.
A hold also suspends the start deadline, at every depth — a waiting job in a held workflow, or in one held by an ancestor, is not ended as Missed Start Time while the hold is on. The deadline does not move, though, so a job whose Latest Start passed during the hold is ended on the first pass after you release. See Holding a workflow suspends the deadline.
Status Filters
Job status-group filter
In Processes → Job View, the Status(s) filter offers groups rather than the individual statuses in the Job Statuses and Pending and Terminal tabs. Each expands to its constituent statuses for the query:
| Group | Includes |
|---|---|
| On Hold | On Hold |
| Waiting | every waiting status |
| Running | every running status |
| Processing Events | every pending-term status |
| Finished OK | Finished OK, Marked Finished OK, Skipped, Fixed |
| Fixed | Fixed |
| Skipped | Skipped |
| Failed | Failed, Marked Failed, Initialization Error, Missed Start Time |
| Cancelled | Cancelled |
| Under Review | Under Review |
| Lost in Failover | Lost in Failover |
The group names match the status badges. Earlier builds called three of these groups Held, Pending Term and Succeeded. Only the names changed: each group covers the same statuses as before, and a saved filter or bookmarked URL that used one still applies it. The Finished OK group still includes Skipped and Fixed jobs, as Succeeded did.
Fixed and Skipped are selectable on their own. Both were previously reachable only folded into Finished OK, with no way to isolate either — which meant a run's skipped jobs could not be listed at all. They now appear as their own groups in the Status(s) list, and Finished OK still includes them, so it keeps the meaning it always had.
Per-group counts are unchanged by that addition: a Fixed or Skipped job is still counted under Finished OK, so the counts don't shift and don't double-count.
The filter is a closed list of these group names, not a free-text field. Typing narrows to a matching group — including Fixed and Skipped now that both are entries — but an individual status that isn't one of these groups can't be typed in directly.
Workflow status-group filter
In Processes → Workflow View, the Status(s) filter offers coarse groups rather than the individual statuses in the Workflow Statuses tab. Each group expands to its constituent statuses:
| Group | Includes |
|---|---|
| Building | Building |
| Waiting | Wait to Start, Wait Container Job |
| In Process | In Process, Started by User |
| On Hold | On Hold, Parent Hold |
| Completed | Completed |
| Cancelled | Cancelled |
Earlier builds called the On Hold group Held; it covers the same statuses.
Unknown is intentionally ungrouped (not user-facing). Unlike the job query, the workflow API
filters by individual status only, so selecting a group expands to its statuses for the query.
Job Actions
Which actions a job status accepts
A job has 11 lifecycle actions, and each status accepts only some of them. The table below lists which.
Actions surface in two places — the row action menu in a job list, and the Status Update tab on a job's detail panel. Both are driven from the same list. The row menu lists all 11 in alphabetical order and disables the ones the job's status does not accept; the Status Update tab lists only the ones it accepts. Restart included: a Cancelled or Skipped job, whose only applicable action is Restart, offers it in both places rather than reporting that no actions are available.
The Status Update tab reads as a short form. Under Choose a new status: each action the job's status accepts is a button carrying its icon, with its description underneath — so you can read what an action does without hovering anything. The order matches the row menu's. A banner at the top notes that the same actions are also on the job's card in the workflow diagram and in the job row's menu.
Selecting one opens the same dialog the row menu opens, so the reason fields, Restart's Restart on Hold and Reset Retry Count options, and Force Start's warning are all there. From either place, the dialog stays open with the error shown if the action fails, rather than closing. Earlier builds closed the row menu's dialog without showing why the action was refused. Every action is unavailable while the job is being re-read, and when the status accepts none the tab says so. Delete is not offered here, or in the job's row menu: it is not a status change. Delete a job from its card in the workflow diagram or with Bulk actions — see Delete.
| Action | Accepted when the job is… |
|---|---|
| Hold | Any Waiting: status, Released, Late to Start, Wait to Start or Wait to Start (Forced), or Pre-run Failed. |
| Release | On Hold. |
| Cancel | A held, waiting, or non-running failed state — On Hold, Released, any Waiting: status, Late to Start, Wait to Start or Wait to Start (Forced), Pre-run Failed, Job to Be Skipped, Missed Start Time, Initialization Error, Failed, Marked Failed, or Under Review. Not a running job — use Kill there. |
| Kill | A running state: Attempting to Start, Start Attempted, Still Attempting Start, Pre-run Active, Running, or Late to Finish. Kill is the running-job counterpart to Cancel. Never accepted on a container job. For a job on a legacy agent, see Killing a job on a legacy (LSAM) agent — it is refused when the agent's Allow Kill is off. |
| Restart | A stopped/terminal state: Failed, Marked Failed, Initialization Error, Cancelled, Skipped, Finished OK, Marked Finished OK, Fixed, Under Review, or Job to Be Skipped. The dialog offers Restart on Hold and Reset Retry Count — the latter selected by default, so a restart normally returns the job's failure-retry budget to full — and, for a UNIX Command, SAP R/3 Job or SAP BW Process Chain that reported its steps, a Restart Step — or, for a z/OS Batch Job or z/OS Started Task, a Start Step and an End Step: see Restart on a step. |
| Force Start | Any Waiting: status, On Hold, Released, Wait to Start or Wait to Start (Forced), Late to Start, Pre-run Failed, Missed Start Time, or Job to Be Skipped. Refused when the target agent is marked and none of the job's backup agents could take it, or when the job's legacy agent group has nothing to dispatch to — see When a legacy group has no dispatch target. An accepted force start still waits for an agent: while neither the target agent nor a backup can take the job, it stays in Wait to Start (Forced) and is sent as soon as one can — see Wait to Start above. |
| Skip | Any Waiting: status, On Hold, Released, Late to Start, Wait to Start or Wait to Start (Forced), Pre-run Failed, Missed Start Time, or a failed state (Failed, Marked Failed, Initialization Error, Under Review). |
| Mark Fixed | Failed, Marked Failed, Initialization Error, or Under Review. |
| Under Review | Failed, Marked Failed, or Initialization Error. |
| Mark Finished OK | Broad manual override accepted from most statuses: held, waiting (including Job to Be Skipped), starting, running (including Running (To Be Terminated)), failed (Failed, Marked Failed, Initialization Error), Under Review, Lost in Failover, Missed Start Time and Fixed. Not from a pending-term status, Finished OK, Marked Finished OK, Cancelled or Skipped. Forces a successful outcome so dependents proceed. |
| Mark Failed | Broad manual override accepted from held, waiting (including Job to Be Skipped), starting and running statuses (including Running (To Be Terminated)), and from Finished OK, Marked Finished OK, Fixed, Under Review, Lost in Failover and Missed Start Time. Not from a status that is already failed, a pending-term status, Cancelled or Skipped. Forces a failed outcome so dependents react. |
A running container job (a step whose body is a nested workflow) accepts no action. Its outcome is driven entirely by the nested workflow, so the Mark Finished OK / Mark Failed overrides are refused while it runs, and Kill is refused on a container job in any status. To stop the work, act on the jobs in its nested workflow. Earlier builds accepted Kill on a running container, which left it in Running (To Be Terminated) for good while its nested workflow ran on.
Mark Finished OK and Mark Failed set the outcome the platform records, so dependents proceed or react. Neither sends a stop request: the process keeps running on the agent until it ends on its own. Only Kill stops the work.
So a job you mark and then restart can have two runs of the same program alive at once. If you need the work to stop as well as the status to move, Kill it first and mark it afterwards.
The restarted run is not affected by the one it replaced. When the earlier run does finish, its result is discarded rather than applied to the job — it belongs to a run that has been superseded. Earlier builds could let it finish the new run, so a restart appeared to complete in seconds with the old run's outcome.
A frequency can start a skip, not just an operator. A job whose winning frequency carries the Build Status To Be Skipped is now built into Job to Be Skipped and goes through exactly the same deferred resolution described below. Earlier builds created it already-terminal as Skipped, which released its dependents at once and let them complete even when the predecessor they actually depended on had failed. A frequency-driven mark whose gates never open parks indefinitely rather than letting the workflow finish past it. See Scheduling and the run.
Skipping in a live workflow. Skipping a job in a live workflow no longer takes effect immediately. The job is marked Job to Be Skipped (no end time, dependents still waiting), and the engine resolves it to terminal Skipped in sequence — once the job's own start time, job, threshold, resource and expression gates are satisfied, i.e. when it would otherwise have been its turn to start (Skipped (Pending) → Skipped, which stamps the end time and releases dependents). A job that has already reached that point — a Failed or Missed Start Time job past its start window — resolves promptly. The skip is written terminal immediately only when the workflow is already terminal or the job isn't resident in the running graph (the in-sequence sweep could never reach it); a residual mark on a workflow being cancelled or closed is finalized to Skipped as part of that action. A Job to Be Skipped mark does not block a workflow close, and it never reopens a finished workflow.
Restart on a step
A UNIX Command, SAP R/3 Job, SAP BW Process Chain, z/OS Batch Job or z/OS Started Task can be restarted on a step instead of from the beginning, so the agent resumes at that step and the steps that already completed are not run again. The steps on offer are the ones the job's agent reported while the job ran; you choose one, you do not type it. An SAP BW Process Chain reports one step, the chain's log ID, and restarting on it has SAP restart that chain run rather than start a new one — see SAP BW Process Chain. A z/OS job can also stop at an end step, so the agent re-runs a range of steps — see Restarting a z/OS job. No other platform takes an end step.
When you restart a single job of one of these types — from its row menu or its Status Update tab — the Restart dialog reads the job first, then shows one of these:
| The job | What the dialog shows |
|---|---|
| Reported its steps | A Restart Step list: From the beginning, selected by default, then each reported step in order |
| A z/OS job that reported its steps | A Start Step list as above, and an End Step list: To the end of the job, selected by default, then each reported step from the chosen start step on. End Step is unavailable until a start step is chosen |
| Reported none | A disabled Restart on Step control, with This job has not reported any steps yet |
| Any other job type | No step control: the dialog is as it always was |
While the dialog is reading the job it shows Checking whether this job can restart on a step…, and Restart waits until it has finished, so the job cannot be restarted from the beginning by accident. If the job cannot be read, the dialog says Restart Step options could not be loaded. The job will restart from the beginning. and Restart stays available. Restart on Hold and Reset Retry Count work as usual alongside the step. Bulk actions never offers a step.
A $JOB:RESTART or $JOB:RESTARTHLD event restarts on a step through its Restart Step field
under the same rules — see Events. For a z/OS job the field takes start|end, such as
STEP2|STEP4; the start alone, or STEP2|, runs to the end of the job.
The step stays with the job until it finishes OK. While a step is stored, the job's Summary
tab shows it in a Restart Step row under Execution, and the
$RESTART STEP token reads it.
- An automatic failure retry of the restarted run resumes at the same step.
- Every later restart replaces it, and a restart From the beginning clears it.
- Finished OK and Mark Finished OK clear it, and so does the next run of a recurring job. Mark Fixed does not.
Marked SAP child processes take the place of a step. While an SAP R/3 Job has child processes marked Restarting, its next restart runs only those children, so the step control is disabled and reads The marked child processes (N): Only marked child processes run again. A restart that selects children clears any stored step. See Restarting only the failed child processes.
What refuses a step. The restart is refused, and nothing about the job changes, when:
| Message | When |
|---|---|
| Cannot restart on a step: this job has not reported any steps yet. Restart it from the beginning. | The job has no reported steps |
| Cannot restart on a step: the restart step is not one of the steps this job reported. | The step, typically from an event, is not in the job's list |
| Cannot restart on a step: the start or end step is not one of the steps this job reported. | A z/OS range, typically from an event, names a step the job did not report |
| Cannot restart on a step: the end step comes before the start step in the steps this job reported. | A z/OS range runs backwards |
| Cannot restart on a step: only a z/OS job can restart to an end step. Choose a single step. | A step with a | on a job of any other platform |
| Cannot restart on a step: restart on step is not available for … jobs. | The job's agent type cannot restart on a step — an MCP or OS 2200 job, for example, which restarts from the beginning only |
| Cannot restart on a step: restart on step is not available for this kind of … job. | A UNIX job of a type other than UNIX Command, or a z/OS REXX Exec or z/OS Console Command |
| Cannot restart on a step: a Unix restart step may contain only letters, digits and the characters . _ : @ % + = / - | A UNIX step with any other character, such as a space |
| Cannot restart on a step: an SAP R/3 restart step must start with STEP and three digits. | An SAP R/3 step that is not of the form STEP001… |
A step also has to be 1 to 64 characters with no comma.
Both halves run through the relay: it collects the steps the agent reports, and it carries the chosen step to the agent. On a relay that has not been upgraded, a job reports no steps, so the dialog offers none. If a job restarted on a step is sent to a relay that cannot carry the step, the job goes to Initialization Error with RELAY_LSAM_FEATURE_UNSUPPORTED, naming the relay and saying to upgrade it or restart the job without a step. It is never run from the beginning in its place. See Keeping a relay current.
Killing a job on a legacy (LSAM) agent
Kill now reaches the agent that actually holds the process. Until this build, a Kill on a job running on a legacy LSAM machine recorded your intent and stopped there: the job moved to Running (To Be Terminated) and stayed there for as long as the job kept running, because nothing carried the request down to the machine. The job ran to completion regardless.
The request now travels to the machine over the relay's heartbeat:
What that means in practice:
- The agent has to allow it. Each legacy agent has an Allow Kill setting — on by default, but off on an SAP R/3 and CRM agent — and jobs on SAP BW, OS 2200 and BIS agents can never be killed (the row menu shows Kill disabled, with the reason, on an OS 2200 or SAP BW job). A refused kill changes nothing: the job keeps running, does not move to Running (To Be Terminated), and the message says why, for example Cannot kill: agent '…' does not allow its jobs to be killed. Turn on Allow Kill for the agent to kill jobs on it.
- It is not instant. The kill waits for the relay's next heartbeat, so allow up to one heartbeat interval — around 30 seconds by default — before the process stops. The job reads Running (To Be Terminated) in the meantime.
- A killed job reports Failed. There is no kill-specific outcome and no separate "killed" status: the agent reports the process's own termination and the platform records the job as failed.
- You can Kill a job that hasn't reached the machine yet. A job reads Running from the moment it is dispatched, which can be well before a busy or offline relay picks the work up. If no relay has taken the work yet, the kill withdraws it: the job ends Failed shortly after, with the termination description Killed before an agent claimed it, and a relay that reconnects later cannot start it. If a relay takes the work first, the kill is applied on the next heartbeat instead. Earlier builds held the kill until a relay took the work, so a job on a lost relay sat in Running (To Be Terminated) with nothing to move it on.
- Mark Finished OK and Mark Failed withdraw work no relay has taken. Closing a dispatched job this way also withdraws its work if no relay has taken it yet, so a relay that reconnects later cannot run a job you have already closed. Work a relay has already taken is left alone.
- A job can be killed once. Once it reads Running (To Be Terminated) a kill is already in flight, so Kill is not offered again and a second request is refused.
- A kill the agent can't act on is retried, not dropped. If the relay is down, or the agent refuses the stop, the request is offered again on every heartbeat until it is acted on.
- Restarting a killed job doesn't re-kill it. The kill applies to the run you issued it against, and is cleared when that job is run again.
- A platform restart no longer strands it. A job being killed is picked up again when the platform's runtime restarts, so the agent's outcome is still collected and the job reaches its terminal status. Earlier builds did not re-follow a job in Running (To Be Terminated) after a restart, and such a job sat in that status indefinitely even though the agent had already stopped the process and reported the result. A kill is still never re-judged by exit criteria.
If the request can't be recorded at all — an outage between the platform and its own agent service — the job still moves to Running (To Be Terminated) and the action still reports success, but nothing is holding the kill to retry, and Kill is not accepted again in that status. If a job sits in that status well past a heartbeat interval, contact support.
Workflow Actions
When an action lands mid-dispatch
An action you take by hand and the platform's own dispatch pass can reach the same job at the same moment. When that happens, the action is refused as a conflict you can retry rather than being applied over the top of a dispatch already in progress.
Kill is the case you're most likely to see. A job still reading Wait to Start, Wait to Start (Forced), or Late to Start looks like it hasn't started — but if the platform is already dispatching it, Kill reports that the operation is in flight and asks you to retry, instead of reporting that the action is invalid for the status. The distinction matters: the job isn't ineligible, it's momentarily busy, and retrying a second later works.
Cancelling a workflow behaves the same way toward its jobs. The cascade that cancels a workflow's running jobs now takes each job in turn and skips any the dispatch pass is holding, and it re-reads each job before writing — so a job that reached its own outcome in the meantime keeps that outcome instead of being overwritten with Cancelled.
Workflow actions. The UI offers, per workflow-instance status:
| Workflow status | UI actions |
|---|---|
| Wait to Start | Hold · Start |
| On Hold | Release · Start |
| In Process | Hold · Close |
| Started by User | Hold · Close |
| Completed | Hold · Release · Start — each one reopens the finished run (see below) |
| Wait Container Job, Parent Hold, Building, Cancelled, Unknown | (none) |
- Start force-starts a built-but-not-yet-running instance now, ignoring its scheduled start time (moves it to Started by User, which is sweep-eligible and promotes to In Process).
- Release returns an On Hold instance to the queue. An instance that has already run once resumes immediately — it does not fall back behind its original planned start time. That matters after a force-start: start a workflow early, hold it, release it, and it picks up where it left off rather than stalling until the time it was originally scheduled for. An instance that has never run still waits for its planned start time, which is the point of holding it.
- Close force-completes an instance that is In Process, or one sitting in Started by User after a Start reopen. It succeeds only once the remaining jobs are all failed/under-review, and can't be undone. Because that blocking-job check still applies, Close on an ordinary force-start is refused — that instance's jobs are still waiting — so in practice Started by User is closeable only for a reopened run with nothing revived on it. A refusal names both statuses.
- Cancel is retained as an event/programmatic endpoint but is not surfaced in the UI menu; it's accepted on any non-terminal status. Cancel is not accepted on Completed, which the three reopen actions are — closing and cancelling a completed instance stay rejected the way any other terminal status rejects them.
- Delete (soft-delete of the instance + its child jobs) is allowed from Wait to Start, Wait Container Job, On Hold, Parent Hold, Completed, or Cancelled — blocked while actively running (Building, In Process, Started by User, Unknown). Delete is a manual intervention, not a lifecycle action.
Reopening a completed workflow
Hold, Release and Start are offered on a Completed workflow instance, and each one reopens the finished run rather than acting on a live one. Where the instance lands depends on which action you take:
| Action on a Completed instance | Reopens it to |
|---|---|
| Hold | On Hold |
| Release | Wait to Start |
| Start | Started by User |
Reopening clears the recorded end time and asks you to confirm first — a single row raises a Reopen Completed Workflow confirmation naming the instance and where the action will leave it, and a bulk action over a selection containing completed rows confirms how many of them will reopen.
Nothing runs on the reopen alone. None of the three actions revives a job, so the instance rests in its reopened status and is pinned there — it is deliberately not promoted to In Process, and it does not re-complete itself either. That pin lifts only once you Restart (or otherwise revive) a job on it. From Wait to Start or Started by User the instance then moves to In Process on its own; reopened with Hold it still needs a Release as well, the same as any held instance. Once it does run on, it is a genuine second run: when it finishes, its completion events fire again rather than being suppressed as a duplicate of the first run. The pin is recorded on the instance, so it survives a service restart in the window between the reopen and the job.
Start reopen has only two exitsStarted by User is not a deletable status, so an instance reopened with Start and left with nothing revived can only be moved on by restarting a job on it or by Close, which is exactly why Close is accepted from that status. Reopening with Hold or Release instead leaves the instance in a status you can still delete.
Two limits on reopening:
- A nested sub-schedule cannot be reopened. Hold, Release and Start are unavailable on a completed sub-schedule row — a sub-schedule's lifecycle is driven by its parent container job — and the API refuses the call. A bulk selection that includes a completed sub-schedule drops the three actions from its menu rather than partially failing.
- Age doesn't matter. A run that completed before the last service restart reopens the same way as one that finished minutes ago; the instance is loaded back into the runtime on demand.
Restarting or force-starting a job on a completed workflow reopens it as well, with no Hold, Release or Start first: the instance returns to In Process and the job runs. That is true of a run that completed before the last service restart too, which is loaded back first, and the same goes for adding a job to one. Earlier builds left such a run Completed when a job on it was restarted, so the job waited and never ran, and refused to add a job to it.
Reopening also changes what an unattended rebuild will replace — see What an unattended rebuild will and won't replace.
Workflow actions that report success without changing anything
Three cases return success and leave the instance exactly as it was, rather than reporting the action as invalid:
- Hold, Release or Start on a sub-schedule in Wait Container Job or Parent Hold. These states belong to the parent container job, so an operator action on the sub-schedule has nothing to apply — it is accepted and ignored.
- Release on an instance that is already Wait to Start.
- Start on an instance that is already Started by User.
Hold on an already-On Hold instance behaves the same way, as it always has.