Job statuses and actions
- Synopsis
- Full Details
In briefA job's status tells you which gate it is waiting at, or how it ended, and decides which of its 11 actions it accepts. Read the status on Processes, then act from the job's action menu or its detail panel's Status Update tab.
- The action menu lists every action and disables the ones the status refuses.
- Cancel is for a job that hasn't started running; Kill is for one that has.
- Skip in a live workflow takes effect in sequence: the job reads Job To Be Skipped until its turn comes.
- A job with failure retries left waits in Wait Start Time, not Failed.
- Force Start skips what a job is waiting on, but not its agent: a force-started job waits in Wait To Start Forced until its agent or a backup agent can take it.
- Exceeded Max Run Time and a Late to Start badge sit beside the status; neither changes it.
- A job reads Job Running only once its agent confirms the start. Until then it reads Start Attempted, and after about five minutes Still Attempting Start.
- Mark Finished OK and Mark Failed don't stop a running job. Kill it first, or a restart can leave two runs of it alive at once.
- A running container job accepts no action, not even Kill: act on the jobs in its nested workflow instead.
- A cancelled job satisfies no job dependency on it, so its dependents keep waiting.
- A job whose Latest Start passes while its workflow is held is ended as Missed Start Time on the first pass after you release it.
A quick reference for what a job's status means and what you can do about it.
A job's status is only useful if you know what it means and what you're allowed to do about it. Guess wrong, and you restart something that shouldn't be, or leave a run stalled.
- Status Groups
- Badges
- By Situation
- Actions
- Holding a Workflow
Status Groups
What a status is telling you
The groups are the ones the Status(s) filter on Processes offers, and the statuses are spelled as the badge in the Status column shows them. The status reference names them as the Job History report does — Waiting: Start Time there is Wait Start Time here.
| Status group | Examples | What it means |
|---|---|---|
| On Hold | On Hold | Won't run until released. |
| Waiting | A Wait status (Wait Job Dependency, Wait Start Time, Wait Resource Dependency, Wait Machine and the like); Late To Start; Job To Be Skipped; Prerun Failed | Eligible but waiting on something. Expected in a normal run — worth attention once it shows Late To Start as its status or a Late to Start badge (see the Badges tab), or when nothing it's waiting on is going to arrive. Job To Be Skipped means the job has been skipped — by you, or by its frequency — and it will drop out when its turn comes. Prerun Failed needs nothing from you either: the job's prerun command failed, so the job never ran, and it is re-attempted a few minutes later — see A failed prerun is re-attempted. |
| Running | Attempt To Start, Start Attempted, Still Attempting Start, Prerun Active, Job Running, Late To Finish, Job Running To Be Terminated | Actively starting or running. Start Attempted means the job was sent and its agent has not yet confirmed that it started; it reads Job Running once the agent does. Still Attempting Start means no confirmation came in about five minutes — check the job's agent or relay, or resolve the job with Mark Finished OK, Mark Failed or Kill; it is not failed for waiting. See A job is Running only once its agent confirms it. Prerun Active means a legacy LSAM agent is running the job's prerun; the job moves on to Job Running when the job itself starts, and you can Kill it as you would a running job. |
| Processing Events | Failed; Processing Events, Skipped; Processing Events and the other statuses ending ; Processing Events | Done; completion is being processed. Transitional, not stuck. |
| Finished OK | Finished OK, Marked Finished OK, Fixed, Skipped | Ended without failing. Fixed and Skipped are also groups of their own, so you can list just those. |
| Failed | Failed, Marked Failed, Initialization Error, Missed Start Time | Needs attention. |
| Cancelled | Cancelled | Ended by Cancel; it will not run unless you restart it. |
| Lost in Failover | Lost in Failover | A job on a legacy agent, or an OpCon MFT, OpCon RPA or EASE job, whose result a relay could not confirm after a failover or a restart — or a job whose Universal Agent stopped responding while it ran. It may have succeeded, so it is not marked Failed, and its dependents are held. A real result that arrives later still replaces it. |
| Under Review | Under Review | A failed job you have flagged for review. Not final: dependents waiting for a failure are released, but the workflow does not complete until you resolve the job or Close the workflow. |
Badges
Exceeded Max Run Time is a badge, not a status
A job that has run longer than its Max Run Time carries an Exceeded Max Run Time badge beside its status. The status itself doesn't change: the job reads Job Running while it runs and then whatever it ends up with — including Finished OK.
Three things follow from that, and they matter during a run:
- The job has not been stopped. The platform reports the overrun and lets the job finish. If you want it stopped, Kill it like any other running job.
- The badge stays after the job completes. A job that overran and then finished OK is precisely the case the status can't show, so the marker outlives the run. Seeing it on a green job is not a contradiction.
- There is no filter for it. The status filters work on statuses, and this isn't one. The Max Run Time Exceeded row on the job's Summary tab gives the time it was detected.
Nothing reported an overrun in earlier builds — a job could run for hours past its limit and finish looking clean. If a long-running job suddenly starts carrying this badge, the job hasn't changed; what the platform tells you about it has.
Late to Start is sometimes a badge too
Late to Start and Late to Finish are reported now. Nothing ever raised either one in earlier builds, so a job that blew through a late offset looked no different from one running to plan. If jobs in your run suddenly start showing up late, the schedule hasn't changed — what the platform tells you about it has. The same applies to the Job Late to Start and Job Late to Finish notifications, which could never have reached you before.
How it shows depends on what the job is waiting for:
- A job queued to start, or waiting on a conflict, takes the status Late To Start.
- A job still waiting on a dependency, threshold, resource, expression or machine keeps that wait status and gains a Late to Start badge beside it. The status has to stay put so the job's gates still apply — moving it would start the job before what it is waiting for arrived.
Either way you are told once per run, and the notification and job events fire either way. A badged job keeps its wait status, so the Job History report lists it under what it is waiting for; the operator dashboard's Late to Start count does include badged jobs, which is why the two can disagree.
Late to Start is advisory. The job can still start, nothing has been stopped, and — unlike the latest-start deadline — holding the workflow does not suspend it. A job in Late To Finish is still running and still completes normally; Kill it if you want it stopped.
If the job legitimately needs longer, give it longer. Edit a job that has not started yet and
move its Late to Start time past now, and the late mark comes off — it stops reading as late,
because by its new deadline it is not. Setting its Late to Start Offset back to 00:00 removes
the deadline and takes the mark off the same way. That works on a job you are holding too, which matters: a held
job used to come back still marked, and a marked job is never re-checked. A job already in the
Late To Start status goes back to Wait To Start, and one in Late To Finish whose late
time you clear or move past now goes back to Job Running — or to Start Attempted if its
agent has not yet confirmed the start. The notification and events already fired
for that run and do not fire again.
A restart or Force Start gets fresh deadlines. Both late deadlines are measured again from the moment you act, so a job you restart after its deadline has passed is not reported late straight away. A first-run restart before the planned start is measured from the planned start.
By Situation
What you can do, by situation
| The job is… | You can | To… |
|---|---|---|
| On Hold | Release · Force Start · Skip · Cancel | Let it run, push it through, skip it, or stop it. |
| Waiting on a dependency/time/resource/machine | Force Start · Skip · Hold · Cancel | Run it now, skip it, hold it, or stop it. A job waiting for its next failure-retry attempt is in this group too — see the note in the Actions tab. |
| Running | Kill | Stop a job that's actively running. |
| Failed | Restart · Mark Fixed · Under Review · Skip · Cancel | Re-run, accept as resolved, flag for review, skip it, or abandon. |
| Missed Start Time | Force Start · Skip · Cancel | Run it now, skip it, or abandon. On a job set to rerun, missing the deadline retires the rest of its cycle, so running it again gives you a single run rather than the runs it had left. |
| Under Review | Mark Fixed · Restart · Skip · Cancel | Resolve, re-run, skip it, or abandon. |
| Lost in Failover | Mark Finished OK · Mark Failed | Check the job on its machine, then record the outcome. Either action releases its dependents as usual. |
Actions are status-specific: a job's action menu disables the actions its status doesn't accept, and its Status Update tab lists only the ones it does. Cancel stops a job before it runs; Kill stops one that's already running. Restart is available once a job has stopped (Failed, Cancelled, Skipped, …); Release only from On Hold.
Mark Finished OK and Mark Failed are manual overrides accepted from most statuses, including some finished ones (Mark Failed from Finished OK or Fixed, Mark Finished OK from Fixed): use them to force a job's outcome (successful or failed) so the jobs waiting on it move on. Neither is accepted from a ; Processing Events status, Cancelled or Skipped. (A container job, one whose body is another workflow, accepts no action while it's running, and Kill is refused on it in any status. Act on the jobs in its nested workflow instead.)
Both overrides change the outcome the run records. Neither stops the work: the process carries on running on the machine until it finishes by itself. Kill is the action that stops it.
So if you mark a running job and then restart it, the same program can be running twice at once. Kill first when the work has to stop as well. When the original run does finish, its result is discarded rather than applied to the restarted job.
Actions
What the actions do
| Action | Effect |
|---|---|
| Hold | Pause the job so it won't run until released. |
| Release | Take a job off hold. |
| Force Start | Start a waiting job now, regardless of what it's waiting on except its agent. Refused if the target agent is marked and no backup agent can take the job, or if the job's legacy agent group has nothing to dispatch to — the refusal names which. It does not skip the agent check: while neither the target agent nor a backup can take the job, it waits in Wait To Start Forced and starts as soon as one can. |
| Skip | Mark the job so it doesn't run. In a live workflow the skip is applied in sequence (when the job would have been its turn to run), and only then do its dependents stop waiting on it. Skipping a job that has already failed or missed its start time takes effect promptly. |
| Restart | Run a stopped job again (failed, cancelled, skipped, or already finished). The dialog offers Restart on Hold, and Reset Retry Count — selected by default, so the job starts again with its full retry budget. A UNIX Command, SAP R/3 Job or SAP BW Process Chain that reported its steps also offers a Restart Step, to resume at a step instead of from the beginning — see Restart on a step. A z/OS Batch Job or z/OS Started Task offers a Start Step and an End Step instead, to rerun a range of steps. An SAP R/3 Job's failed child jobs can be restarted on their own from its Child Processes table — see Restarting only the failed child processes. |
| Mark Fixed | Treat a failed job as resolved (work done outside the system). |
| Under Review | Flag a failed job for follow-up. |
| Cancel | Stop a job that hasn't started running yet. A cancelled job satisfies no job dependency on it, so its dependents keep waiting: Skip, Force Start or Cancel them too. |
| Kill | Stop a job that's actively running. (Cancel doesn't apply once a job is running.) On a legacy LSAM machine it takes up to one relay heartbeat to land — see the note below. |
| Mark Finished OK | Force a job to a successful outcome so its dependents proceed. Does not stop a running job — see the By Situation tab. |
| Mark Failed | Force a job to a failed outcome so its dependents react accordingly. Does not stop a running job — see the By Situation tab. |
A job whose frequency configures failure retries does not go to Failed while it still has attempts left. It waits in Wait Start Time with the failed attempt's exit code and termination description still showing, and its dependents keep waiting — so nothing downstream reacts until the job is genuinely out of budget. The job's Summary tab shows Retry Count as used-of-maximum.
If you do not want the attempts it has left, Restart or Cancel the job rather than waiting for them. A restart clears the pending attempt, and returns the count to zero unless you clear Reset Retry Count. See Failure retries.
A cancel now stays cancelled. A job cancelled before it ever ran could previously be picked back up by the retry gate while it still had budget — so the cancel appeared to work and the job then ran anyway. A job that ran nothing is no longer eligible for a retry.
The kill is carried to the machine on the relay's next check-in, so allow around half a minute before the process actually stops. The job reads Job Running To Be Terminated until then, and once the process stops the job reports Failed — there's no kill-specific outcome. A kill the machine can't act on yet is retried, not dropped, so you don't need to re-issue it — and you can't: Kill is not accepted again once a job reads Job Running To Be Terminated.
If the relay never picked the job up, the kill withdraws it. The job ends Failed shortly after, reading Killed before an agent claimed it, and a relay that comes back later won't run it. Mark Finished OK and Mark Failed withdraw such a job's work the same way.
The machine's agent has to allow it. A kill is refused, and the job keeps running untouched, when the agent's Allow Kill setting is off — the default on an SAP R/3 and CRM agent — or on an SAP BW, OS 2200 or BIS agent, whose jobs can never be killed. The message says which, for example Cannot kill: agent '…' does not allow its jobs to be killed. An administrator can turn Allow Kill on for the agent — see Allow Kill.
Kill is not offered on an OS 2200 or SAP BW job. The job's own type decides this, so the row menu shows Kill unavailable with the reason Jobs on OS 2200 agents cannot be killed. (or SAP BW), and the bulk action bar leaves Kill out as soon as one such job is in the selection. If a kill request reaches one of these jobs another way, it is refused the same way, and the job keeps running.
Earlier builds never carried the request down to the machine at all: the job sat at Job Running To Be Terminated and the process ran to completion. If you have a runbook step that works around that, it can go.
Occasionally you'll act on a job at the same instant the platform is starting it, and the action reports that the operation is in flight. Nothing is wrong and nothing was half-applied — the job is momentarily busy. Wait a second and try again.
You're most likely to see this on Kill for a job that still reads as waiting to start. It's also why cancelling a whole workflow leaves a job alone if that job has just reached its own outcome: the cancel doesn't overwrite a result that already arrived.
Holding a Workflow
Hold on a workflow that contains container jobs holds every workflow below it, at every depth — each one reads Parent Hold and none of their jobs starts. Releasing the one you held resumes the whole tree; you don't need to release each level.
Two things to expect. A workflow you held directly keeps reading On Hold, not Parent Hold, even while something above it is also held — so releasing the ancestor does not release it, and you have to release it yourself. And a held workflow still finishes work already running; a hold stops new jobs starting, it does not freeze the run mid-job.
Earlier builds only reached one level down, so holding the top of a three-level design stopped the middle and left the bottom running. If you have a runbook step that holds each level in turn, it can go.
While the hold is on, waiting jobs are not ended for missing their start deadline. Holding a workflow to investigate used to do exactly that: a job whose Latest Start passed during the hold went to Missed Start Time — terminal — and releasing the hold did not bring it back. So the hold you placed to buy time destroyed the run you were protecting. It doesn't now, at any depth.
The deadline does not move, though. It is measured from the schedule date, so a job whose Latest Start passed while you were holding is ended on the first pass after you release. The hold defers the decision rather than extending the window — if you need the job to run, have its Latest Start pushed out before you release, or Force Start it. Late to Start is still raised under a hold, and a job already running is unaffected.
Related topics
- Job and workflow statuses — full configuration reference and troubleshooting
- Respond to a failed job (Operator)
- Monitor the daily run (Operator)