Acting on runs in Processes
- Synopsis
- Full Details
In briefFrom Processes you act on the run: you schedule a workflow into it, act on one job or workflow instance or on several at once, add a job defined on the workflow to an instance that is already running, and correct a job on a run under way. An edit changes that instance only, until you promote it to the workflow with Push Changes to Workflow.
WhereOperations › Processes (see The Processes page (runtime)). Schedule Workflow is on the page. Each row has an action menu, and a Bulk actions button appears once two or more rows are selected. Add Job and Job Actions are in a workflow instance's row menu in Workflow View. The job editor opens from Edit Job on a job's node in the workflow diagram, and Push Changes to Workflow sits in its footer.
When
- You need to act on one job or workflow instance, or on several at once, or on every job in one workflow instance.
- You want to schedule a workflow into the run, for up to 31 days in one pass, or add a job defined on the workflow to an instance that is already running.
- You need to correct a job on a run under way, and possibly promote that edit to the workflow.
Use something else when you only need to read the run, filter it, or open a job's detail and output: see The Processes page (runtime). When you need to know what a status or action means, see Job and workflow statuses.
How
- Open Operations › Processes, and check the environment above the page.
- Use a row's action menu for one job or workflow instance, or select two or more rows and use Bulk actions, which offers only the actions every selected row accepts. To change every job in one workflow instance, use Job Actions in its row menu in Workflow View.
- To add a job to a running instance, open Add Job from the instance's row menu in Workflow View.
- To correct a job on a run under way, open Edit Job on its node in the workflow diagram. Use Save for this instance, and Push Changes to Workflow when every future build needs a change to its task settings, tags or custom fields too.
For the full steps, see Work the Processes page.
- Changing page, sort, search or a filter clears the row selection, so a bulk action never acts on rows you cannot see.
- Job Actions on a workflow instance changes only the jobs whose status allows the action, and reports how many it skipped and why.
- An edit in the job editor changes this instance only. Push Changes to Workflow writes the task settings, tags and custom fields to the workflow definition as a new version, and nothing else. A container job's Sub-Workflow cannot be changed on an instance.
- A Success Reruns change is refused on a finished job that nothing will run again (turning reruns off is accepted), on Restart Offset with neither Maximum Runs nor a latest runtime, and when new instance times or a new latest start time would put the next rerun or failure retry past the latest start. Maximum Runs can be cleared on an instance.
- Each action needs its permission in the workspace of the workflow the instance was built from. See Who can do what on Processes.
- Kill stops the process only on a legacy (LSAM) agent. On a Universal Agent the process keeps running.
- One tick of Overwrite Existing applies to every date in the range. Read the count in the confirmation first.
- Hold, Release and Start on a completed workflow reopen it. Read the Reopen Completed Workflow confirmation first.
Task walkthrough: Work the Processes page. To read the run, filter it, or open a job's detail and output, see The Processes page (runtime).
This page covers what you can do to a run from Processes: schedule a workflow into it, act on one job or workflow instance or on several at once, delete them, add a job to an instance that is already running, and correct a job on a run under way, then promote that edit to the workflow when every future build needs it.
- Scheduling
- Row and Bulk Actions
- Adding Jobs
- Multi-Instance Jobs
- Editing a Running Job
- Push Changes
Scheduling
Scheduling a workflow across a date range
Schedule Date takes a range, not just one day, and opens on today. Building a workflow for a week is one pass through the dialog instead of seven, each of which used to mean re-picking the workflow, the schedule instance, the property overrides and both check boxes.
| About a date range | How it works |
|---|---|
| How much you can ask for | Up to 31 days in one submission. A longer range is refused in the form — "Select at most 31 days — this range covers 45." — and Schedule stays disabled until it fits. Building further ahead than that is what the automatic daily build is for. |
| How it runs | One build per date, in sequence. Each build expands its own container hierarchy and reads the deployment list for its own date, so a month of them at once would be a self-inflicted rate limit. The date count and the range appear under the field — "5 dates, 2026-10-01 through 2026-10-05 — one build per date." |
| What the Workflow list offers | The workflows deployable on the range's first date. Deployment windows are per-date, so intersecting across the range would hide workflows you can legitimately build on most of the days you picked. A workflow that only becomes deployable later in the range is not listed — move the start date to reach it. |
| Picking the range | Turn Date Range on, then pick the first day and the last. The first day you pick starts the range, even though the field opens on today. If the second day is earlier than the first, the two are swapped. Picking again on a range you already chose starts a new one. Earlier builds kept today as the start, so the first pick only set the end. |
| A range you start and abandon | If you pick the first date of a range and then close the calendar without picking the second, the field keeps that one day, and the build is for that single date. Open the calendar again and pick both ends to set a range. |
| Property overrides and both check boxes | Apply to the whole range. Every date resolves the same deployment, so the instance names, the declared override fields and the instance list in the confirmation hold for all of them. |
One refused date no longer abandons the rest. A range typically fails on exactly the dates a deployment does not cover, so each date is reported with its own reason rather than the whole submission reading as nothing was built. The dialog closes only when something was built and every date answered; anything else keeps it open with the per-date report in it, so you can tick Overwrite Existing and retry without re-entering the form. A range that landed reports as "Scheduled 3 of 5 dates", naming the dates that got nothing and, where instances failed, which instance failed on which date.
The check box's hint and every variant of its confirmation state the date count beside the instance count, because the two multiply: a fan-out of five instances across 31 days is 155 runs deleted by one tick. Read the count in the confirmation before you accept it with OK. While the range is building, the confirm button carries the progress — Overwriting… (4 of 31) — since the confirmation, not the form behind it, is the only surface you can see for the whole loop.
Whatever the range, the warnings that belong to the dates that did build are still raised: container jobs the build left with nothing to run, and instances an overwrite irreversibly deleted. Both appear on no count and in no instance list, so a range refused on its last date no longer discards them.
Row and Bulk Actions
Row actions (single job)
Each row has an action menu listing every job action in alphabetical order, with the ones the job's status does not accept disabled — the status-gated set (see Job statuses and actions): Hold, Release, Cancel, Kill, Restart, Force Start, Skip, Mark Fixed, Under Review, Mark Finished OK, Mark Failed. Cancel applies to a job that hasn't started running; Kill is its running-job counterpart. A running container job offers no action: its outcome follows its nested workflow, and Kill is refused on a container job in any status. Earlier builds offered Kill on a running container, which left it in Running (To Be Terminated) for good.
If the platform refuses an action, its dialog stays open and shows the reason. Earlier builds closed the dialog from the row menu with no message.
Cancel asks first, with Cancel / OK. The Cancel Job dialog reads This will cancel the job. — the same description the Status Update tab shows beside Cancel. OK cancels the job; Cancel closes the dialog and leaves the job as it was. Earlier builds labelled both buttons Cancel, and added that the agent would try to stop the job if it was running, which never applied: Cancel is not offered on a running job.
Kill stops the process only on a legacy (LSAM) agent, through its relay. On a job running on a Universal Agent, Kill is accepted and the job's status records it, but nothing reaches the agent: the process keeps running until it ends on its own or reaches the agent's fixed one-hour limit. See How a Universal Agent takes and runs work.
A legacy Kill is delivered even if it cannot be handed on at once. While the job reads Running (To Be Terminated), Continuum sends the kill again about once a minute until the platform that hands it to the relay accepts it, so a kill made during a brief outage still reaches the job. You do not need to — and cannot — kill it again. Earlier builds sent it once, and a kill that could not be handed on left the job in Running (To Be Terminated) for good.
Some legacy jobs cannot be killed at all. A job on an SAP BW or OS 2200 agent has no
Kill in its Status Update tab or in a Bulk actions menu that includes it, and its row menu
shows Kill disabled with the reason "Jobs on OS 2200 agents cannot be killed." (or SAP BW). A
Kill that reaches the platform anyway is refused with "Cannot kill: jobs on OS 2200 agents cannot
be killed", naming the agent. On other legacy agents the Allow Kill setting of the agent the job runs on decides; for a job that was sent to a backup agent, that is the backup agent's setting.
When it is off, Kill is refused with "Cannot kill: agent '<name>' does not allow its jobs to be
killed. Turn on Allow Kill for the agent to kill jobs on it." If the platform cannot check that
setting, Kill is refused with "Cannot kill: the agent's kill setting could not be checked because
agent-service is unavailable. Try again." A refused Kill writes nothing, so the job's status is
unchanged. See Allow Kill. If an MCP agent itself declines a
kill, the job keeps running and finishes with the result the agent reports.
Row actions (single workflow instance)
A Workflow View row menu holds Edit, Add Job, Hold, Release, Start, Close, Job Actions and Delete. Hold, Release, Start and Close are enabled only when the instance's status accepts them; Delete only for a deletable status, and never on a nested sub-schedule. The per-status set is in Job and workflow statuses.
On a Completed row, Hold, Release and Start reopen the finished run, so the row menu treats them differently from an action on a live instance:
- They confirm first, in a Reopen Completed Workflow dialog that names the instance (including
its
$nnnnrun suffix) and says where the action will leave it. The alternative is labelled Leave Completed. - They are unavailable on a completed nested sub-schedule, which can't be reopened. On any other status a nested sub-schedule's ordinary lifecycle actions are offered as normal.
- Any other status is unaffected: those actions fire directly, with no confirmation, exactly as before.
A failed Hold, Release or Start reports on a page-level alert; Close reports inside its own dialog.
A failed action is sent once. If an action or a build times out, loses its connection, or the service answers with a server error, the page reports the failure rather than sending it again on its own. The service may still have applied it, so check the job or instance before you try again.
Job actions on a whole workflow instance
Job Actions, in a Workflow View row menu, applies one job action to every job in that workflow instance in one step. Its submenu offers Cancel, Hold, Mark Failed, Mark Finished OK, Mark Fixed, Release, Restart, Skip and Under Review. Force Start, Kill and Delete are not offered here: use them on one job at a time.
| Step | What happens |
|---|---|
| You pick an action | A Change Job Status dialog loads the instance's jobs as they stand now. It covers the instance's own jobs, a container job included, but not the jobs inside the container's nested sub-workflow. |
| The confirmation | It says how many jobs will change, and how many will not because their status does not allow the action. Each job is checked with the same rule as its own row menu (see Which actions a job status accepts), so a running container job accepts none. If no job will change, the dialog says so and offers only OK. If the jobs cannot be loaded, the dialog says so and nothing is changed. |
| The run | Select Change Status (or OK for Cancel and Mark Failed). Each job is changed on its own, with the same permission check, job history and audit record as a single-job action. The jobs are taken in dependency order: Hold, Release and Restart act on a predecessor before the jobs that depend on it, and the other actions act on the dependent jobs first, so a dependent job cannot start before its own Cancel or Skip reaches it. The dialog stays open, and cannot be closed, until every job has been tried. |
| The result | The dialog reports how many jobs changed, and how many did not, grouped by reason: Their status does not allow this action., Their status changed before the action ran., Another action was in progress on them. Try again., You do not have permission to change them., or The action failed. with the error behind it. |
On a Completed instance, Hold, Release and Restart reopen the workflow, and the confirmation
adds "<name> already completed, so this reopens it." On a Completed nested sub-schedule,
which cannot be reopened, those three are disabled, with the reason "A completed nested workflow
cannot be reopened."
Job Actions is unavailable on a row while another action on that row is still in progress.
Bulk actions
Both views support multi-row selection, per row or all at once. A Bulk actions button appears once 2+ rows are selected — and, in the Job View, stays available for a single selected row that failed in the last bulk action, so it can be retried. Its menu is the intersection of the valid actions across the selection (an action shows only if every selected row accepts it) plus Delete when every selected row can be deleted; actions run as a batch and a confirmation message reports the result in both Job View and Workflow View.
A Job View page the action empties is not left blank. When a bulk action moves every row on the last page out of the current filter — Mark Finished OK with only jobs with errors shown, for example — the view steps back to the last page that still has rows.
Two carve-outs on a Workflow View selection, both because status alone doesn't decide whether Hold, Release and Start are legal on a Completed row — those three reopen a finished run:
- If any selected row is a Completed nested sub-schedule, Hold, Release and Start are dropped from the menu. A sub-schedule can't be reopened, so offering them would fail part of the batch.
- If the selection contains any Completed row at all, those three actions confirm first, naming
how many completed instances will be reopened — the same treatment Delete already gets. A mixed
selection is the easy way to reopen a run without meaning to. The confirmation is titled
Reopen
Ncompleted workflow instances? and says that nothing runs until you restart a job. Earlier builds, although they were meant to ask, ran the action at once without this confirmation.
Delete (jobs and workflow instances)
Delete is a manual intervention (soft-delete), not a lifecycle action, so it is not in a job's row menu or its Status Update tab. Delete a job with Delete Job on its card in the workflow diagram, or with Bulk actions; delete a workflow instance from its row menu or with Bulk actions:
- Delete a job instance drops the dependency edge from every dependent (same- and cross-workflow) so downstream jobs re-qualify against their remaining conditions instead of hanging on a predecessor that no longer exists; dropped edges are persisted so a restart doesn't re-block them. Rejected while the job is running (kill it first) or in a pending-termination status.
- Deleting a container job takes its nested sub-workflows with it. A container job is deleted together with the sub-workflow it holds and every level below that, so no nested run is left behind pointing at a job that no longer exists. Each nested instance has to pass the same checks a workflow-instance delete applies — a deletable status, and no running or pending-termination job inside it. If any level fails, the whole delete is refused and nothing is removed, so a container is never half-deleted. Dependents of the nested sub-workflows re-qualify as they would for an ordinary delete, including those that named a nested job by name rather than resolving it.
- Delete a workflow instance soft-deletes the instance and cascades to its child jobs (parity with job delete), tearing them out of the runtime dependency graph and re-qualifying surviving cross-workflow dependents. Allowed only from a deletable status — Wait to Start, Wait Container Job, On Hold, Parent Hold, Completed, Cancelled — and blocked while actively running (Building, In Process, Started by User, Unknown), or when a child is running/pending-term. A nested sub-schedule cannot be deleted on its own — it is managed by its parent workflow.
Adding Jobs
Add a job to a workflow instance
An operator can add a job that is defined on the workflow to a running (or resident) instance
of that workflow — the equivalent of the legacy Add Jobs wizard ($JOB:ADD /
$JOB:ADDHLD), re-shaped to OpCon Continuum's synchronous in-process model. The trigger is an Add Job
item in the Workflow View row action menu; it opens the Add Job to Workflow Instance dialog.
Candidate list. Candidates come from the live workflow definition, not the instance's frozen config snapshot — so a job added to the definition after the instance was built still appears. The dialog shows a sorted radio list of every defined job, each badged with its disposition:
| Disposition | Badge | Selectable? |
|---|---|---|
| addable | (none) | Yes — not currently in the instance |
| replace | Will Replace | Yes — already ran and is in a terminal status; adding replaces it |
| copy | Will Add Copy | Yes — a multi-instance job with an instance still live and none finished; added as a numbered copy beside it |
| active | Job is Active | No — already present in a non-terminal status |
| no-frequency | No Frequency | No — the job defines no frequency, so it can't be instantiated |
A job whose Disabled switch is on also carries a Disabled badge, in addition to whichever disposition badge applies. It is still selectable, deliberately: adding it by hand is the way to run a parked job once, and the build never would have.
Multi-instance, workflow-container and run-on-all jobs are all supported: workflow-container and run-on-all jobs below, and multi-instance jobs on the Multi-Instance Jobs tab. The backend re-fetches the deployment and stays authoritative on whether a job is actually addable.
Dialog inputs.
- Frequency — a choice is required when the job defines more than one; auto-selected when it defines exactly one.
- All Instances / Instance — shown only for a multi-instance job, and one of the two is required. See Adding a multi-instance job.
- Property grid — a grid of property names, values and an Encrypted column, pre-filled with the
job's default property set. For a multi-instance job it appears once you pick an Instance,
filled from that instance's properties, and is not shown with All Instances. Sent to the
backend only if edited; an untouched add keeps the deployment's (environment-transformed) property
values. A property marked
encryptedbut carrying a plaintext value is rejected. - Add on Hold — a check box. Released → the job lands at Waiting: Start Time (so it runs regardless of whether its frequency qualified for the date); on hold → On Hold.
- Reason — optional free text recorded on the audit history entry.
Duplicate gating. A job already active in the instance rejects — except an instance of a multi-instance job, which is added as a numbered copy beside the live one. A job present only in a terminal status is replaced (the dialog warns first, then soft-deletes the prior instance and re-points its dependents onto the new job).
A replacement is one transaction: the previous run is not deleted unless the new job is written in its place. And the previous run is re-checked as still terminal inside that transaction, so if somebody restarted it between the dialog reading it and your Add, nothing is written and the add reports that the row changed — restarted, or replaced by another add — rather than overwriting a run that is live again.
A dependent the replacement could not be wired to keeps waiting. Re-pointing dependents onto the new job covers the ones in the same workflow. A dependent in another workflow, or one whose re-point did not take, is left waiting rather than released:
- A cross-workflow dependent re-resolves onto the replacement by name, so it picks the new job up on its own.
- A same-workflow dependent that could not be re-pointed stays unsatisfied, and keeps waiting until you act on it.
Either way the dependent holds rather than running early. Earlier builds dropped these dependencies instead, so a dependent that should have waited for the replacement ran straight away — and because the stripped dependency was saved, a restart did not put it back.
An added job whose own dependencies cannot be wired is kept, but cannot start. If the job you
add depends on jobs in the same workflow and those dependencies cannot be recorded, the add stands
and the dialog says so: "<job> was added but cannot start — its dependencies could not be
resolved. Remove it and add it again."
Adding a workflow-container job
Adding a workflow-container job expands its sub-schedule immediately, the same way a build does — the child workflow's jobs are materialized with it rather than waiting for dispatch. Two limits:
- Top-level instances only. Adding a container job to a nested instance is left to dispatch rather than expanded here.
- Replacing a container job is refused while its sub-schedule is still live. Replacing it would orphan the child run — jobs still going with nothing left that owns them — so the add is refused and tells you so. Wait for the sub-schedule to finish, or close it, then add again.
Replacing a container job that has finished discards its old sub-schedule properly: the child is soft-deleted and evicted from the running schedule, so it does not linger.
Dependency wiring. A dependent that cannot be rewired — most often one deleted between the dialog reading the definition and the add — is retried once on its own and then skipped, so it no longer costs every dependent after it its edge.
Same-workflow dependencies are resolved by GUID and pruned against the jobs
actually materialized in the instance — except an authored Requires or After, which
survives and is marked absent instead of being dropped. That is what a normal build does, so an
added job now waits on a Requires predecessor that didn't qualify for the date, rather than
dispatching immediately as though the dependency had never been authored. Reverse-dependents (jobs
waiting on the added job) are rewired from the live definition; an add that would create a
dependency cycle is rejected (400).
Reopen. Adding a job to a Completed resident instance reopens it (Completed → In Process) via
a job recount so the new job can dispatch; if the best-effort graph sync fails, the instance is left
Completed rather than churning. The add records an ADDED job-history entry at the landing status
(the job appears on the workflow timeline; audit parity with Classic's "Job Added").
You are recorded as the job's last modifier, not the platform. Adding a job resolves its dependencies immediately afterwards, and that resolution used to stamp the build service as the job's last-modified-by — so a job you added by hand was attributed to the platform the moment it landed. The job now carries you. A job the nightly build adds is still attributed to the build, which is correct for it.
Adding a run-on-all job
A job assigned to a legacy agent group in run-on-all mode runs once on every member of the group, and a build fans it out into one job per member. Adding one to a running instance does the same thing: the group's membership is resolved when you add, and you get one job per member, each named and assigned exactly as the build would have named it.
| The job | Each added job is named |
|---|---|
| An ordinary run-on-all job | <job>__<member> |
| A multi-instance run-on-all job | <job>.<instance>__<member>, for every instance × member pair |
Each one is pinned to its own agent, goes through its own duplicate gate, and reports its own outcome — so a group where one member is already running the job tells you that about that member, not about the add as a whole.
The group is read when you add, not when the workflow was built. An agent added to the group since the build is therefore included.
Only a legacy group fans out. A Universal Agent pool set to run-all is added as a single job, which is also how the build treats it.
The add is refused, naming the group, when:
- the group has no members — there is nothing to fan out to;
- two members share a name, which would collide on the projected job name;
- the group cannot be read — it no longer exists, or the request for it was rejected.
Two further limits are worth knowing:
- Instances × members is capped by the same fan-out limit a build uses. Over it, the add is refused and asks you to add instances one at a time.
- An ad-hoc instance of a run-on-all job is refused. Adding a multi-instance job
from a
$JOB:ADDevent can name an instance that the job does not define; a run-on-all job cannot, because its added jobs are numbered against its per-member rows. Name one of its defined instances, or add it without properties to get them all.
In the dialog, a plain run-on-all job's disposition is read from its per-member jobs rather than a single job under the bare name, because the bare name is never in the instance: every member still running reads as Job is Active, and any member that has finished makes it a Will Replace whose confirmation covers those jobs. A job whose group has not been picked yet is treated as an ordinary job, which is how the run time treats it too.
Preconditions & scope. The add is rejected (409) when the workflow instance is Cancelled; the UI disables Add Job for Cancelled. A Completed instance that is no longer held in the running schedule — after a service restart, for example — is loaded back first and then reopened as above; the add is rejected (409) only if that reload is refused. A target instance in another environment is masked as not-found.
Multi-Instance Jobs
Adding a multi-instance job
A multi-instance job runs once per property group, under the projected name
<job>.<instance>. Adding one offers a choice:
| Control | Adds |
|---|---|
| All Instances | One row per instance the job defines — the same fan-out, under the same projected names, that a build would have produced |
| Instance | Just the one you name from the list of the job's instances |
Each instance is judged and reported on its own. That is the point of the fan-out, and it has three consequences worth knowing:
- Duplicate gating is per instance.
EXTRACT.USbeing active does not refuseEXTRACT.EAST— they are independent runs. - One instance failing does not block the rest. An All Instances add reports an outcome per instance, so a conflict or a failure on one still adds the others.
- A job that defines no instances is refused rather than added under its bare name, and an instance with no name, or a duplicate name, is refused for the same reason: the projected name is what the rest of the run identifies it by.
A projected <job>.<instance> name longer than 255 characters is refused up front rather than
failing on the write.
Its disposition badge is read per instance, too. A multi-instance job is never in the instance
under its bare name, so the dialog reads each instance's own <job>.<instance> row — the exact name
the add will materialize. A job with any instance that has already finished shows Will Replace,
and the replacement confirmation names the instances it covers; otherwise a job with an instance still
running shows Will Add Copy and stays selectable. Earlier builds looked for a row under the bare name,
which never exists, so a multi-instance job was always badged as freely addable and the
Will Replace warning never appeared. If the job also runs on each agent of a legacy agent group,
the per-agent <job>.<instance>__<agent> rows are read the same way.
A live instance gets a copy, not a conflict
Adding an instance that is still running or waiting adds a numbered copy beside it. Earlier
builds refused it — Job "JobA.US" is already active in this instance — which meant the one case a
multi-instance job exists for, a second run of the same instance while the first is still going,
could not be asked for at all. It now behaves the way an
ad-hoc instance already did:
- The copy takes a
$NNNNsuffix on its instance name —JobA.US$0001beside the liveJobA.US. - The lowest finished
$NNNNcopy is reused (replaced, as any finished duplicate is); otherwise the number is one past the highest copy, starting at$0001. When a copy will be reused, the dialog badges the job and the instance Will Replace, names the copy it replaces, and asks you to confirm, as for any replacement. An add that reuses no copy adds the new number without asking. - A number that would spell one of the job's own instance names is skipped, so a copy never collides with a defined instance.
- Past
$9999the add is refused — for that instance only, so an All Instances add still adds the others. The same is true of a copy name too long to fit. - A job that is not multi-instance still rejects when it is active. Nothing is numbered there.
This covers every way you can ask for the instance: naming it in the dialog, an All Instances
fan-out, and a property-carrying $JOB:ADD whose first value
names one of the job's instances. An event that targets
an exact name still acts on that exact name.
A copy matches dependencies as its instance, not as its own name. This is what makes the copies useful rather than orphans:
| Relationship | What happens |
|---|---|
JobB.US waits on JobA.US | It waits on JobA.US and every copy of it |
A job in another workflow waits on JobA.US | The same: JobA.US and every copy of it in that workflow instance, including a copy added after the dependency was first checked |
A dependency names an exact copy, JobA.US$0001 | Only that copy |
JobA.US$0001 has predecessors | It waits on whatever JobA.US waits on, copies included |
A row whose instance name genuinely is US$0001 | Read as that instance, not as a copy of US |
A copy keeps the instance it was made beside even if the definition later renames or removes that instance, so a run in flight is not re-interpreted underneath you.
Earlier builds had a job in another workflow wait only on JobA.US itself, so it could start while
a copy was still running. Deleting JobA.US now leaves that dependent waiting on a copy that
remains; the dependency is dropped only when the last of them is deleted.
On a job that also runs on each agent of a legacy agent group, copies are numbered per
member, with the number ahead of the member suffix — JobA.US$0001__AG1. One member's copies do not
count toward another's numbering.
- An instance named to look like a copy —
US$0001sitting besideUS— is read as itself while it is in the definition. If it is removed from the definition, a run of it is then read as a copy ofUS. - A copy whose base row has been deleted, and whose instance was then renamed or removed, is no longer matched to that instance. Dependencies on it hold rather than resolving.
Adding a multi-instance job from a $JOB:ADD event
A $JOB:ADD / $JOB:ADDHLD event names a job but has no way to name an instance, so it cannot make
the choice the dialog asks for. Earlier builds simply refused such an event. It now follows Classic's
default, and what it adds depends on whether the event carries a properties value:
| The event carries | What is added |
|---|---|
| No properties | Every instance the job defines — the same fan-out, under the same projected names, as All Instances |
| Properties, and the first value names one of the job's instances | That instance, with the event's properties merged over its own |
| Properties, any other first value | One ad-hoc instance, named from the first property's value, with the event's properties merged over the one instance it is based on, if any — see The instance an ad-hoc instance is based on |
A job that is not multi-instance is an ordinary add either way — the event asks for the fan-out only if the job turns out to have one.
DefaultEarlier builds put a property-carrying add on the job's Default instance whenever the job had one,
and the designer gives every job a Default — so a second add with a different value collided with
the live Job.Default and failed with a conflict, which is exactly the case a multi-instance job
exists for. Classic names every multi-instance run from its property values, and so does this now:
Property=1 is its own instance beside Property=0.
To write onto Default deliberately, send Default as the first property's value, or name it in
instanceTarget where the caller has that field — an API field the dialog and an event do not have.
Matching the first value against the job's instances. The value is matched ignoring case,
against the value as sent and then against the name it cleans down to — so Env=default adds the
job's Default instance rather than building Job.default beside it, and an instance named R&D is
still reachable even though & is not a character an instance name can hold. A value that matches
two instances on case alone is refused rather than taking whichever the job lists first.
Merging the properties. A property the event names replaces the instance's own, one it does not
name is kept as it stands, and a name the instance does not define is added. Names are matched
case-insensitively, the way a [[JI.…]] token reads them — so REGION in the event overrides
the instance's Region instead of landing beside it and losing to it. A property the instance
declares encrypted cannot be set this way, and the event fails naming it.
The instance an ad-hoc instance is based on
An ad-hoc instance's properties are the event's merged over one of the job's instances, picked the way Classic picks it, so a property the event leaves out keeps that instance's value rather than being absent:
| The job defines | The ad-hoc instance is based on |
|---|---|
| One instance, whatever its name | That instance |
| Several instances | The first, in the order the job lists them, whose first property has the same name (ignoring case) and the same value (exactly) as the event's first property. An instance whose first property is encrypted is never matched |
| Several, and none matches | None — the instance carries the event's properties exactly as sent |
Default is not treated specially. On a job with several instances, an ad-hoc instance takes
Default's values only when Default is the instance it matches. Earlier builds based every ad-hoc
instance on Default whenever the job had one, so values the event did not send were silently
filled in from it.
Ad-hoc instances. The name is taken from the first property's value — up to any further =,
with line breaks and tabs turned into spaces and the characters a job name cannot hold removed,
including the . that separates a job from its instance — then trimmed. A value that leaves
nothing usable no longer fails the add: the instance is named AdHoc instead. An ad-hoc instance
is refused when:
- the job's own name leaves no room to append one;
- the name spells one of the job's defined instances although it came from no value — an add
from a legacy agent, which is always named
AdHoc, or a value that cleaned down to nothing, onto a job that has an instance namedAdHoc. Rename that instance; - a same-workflow predecessor or dependent of the job is multi-instance. Those are matched up
instance by instance (
B.EASTwaits onA.EAST), and an ad-hoc name takes no part in that matching: as a dependent it would wait on every instance of the predecessor, and a dependent waiting on one of the job's own groups would go on waiting for that group. The message says which relation blocked it, and what an event can do instead: "To add one of the job's instances, make the first property's value that instance's name; to add every instance, add it without properties." An event has no field to name an instance, so those are its two ways forward. Classic accepted this add, because it matched job dependencies by job rather than by instance.
A repeat ad-hoc add is numbered rather than refused. When the name is still held by a run that
hasn't finished, the instance takes a $NNNN suffix the way Classic numbers a multi-instance
duplicate: the lowest-numbered $NNNN copy that has finished is reused — replaced, as any finished
duplicate is — otherwise it is the next number after the highest copy, starting at $0001. A
finished un-numbered instance is replaced as usual. Past 9999 copies in one workflow instance the
add is refused.
The job's own defined instances are numbered the same way now. They used to be exempt — a live
Default was a conflict rather than something to number around — because a copy's name was what
dependencies matched on. A copy is matched by the instance it belongs to instead, so the exemption
is gone: see A live instance gets a copy, not a conflict.
An event raised by a legacy agent names its ad-hoc instance AdHoc instead of using a property
value, because an agent's properties are redacted and a job's name is not — see Secrets in an
agent-raised event.
Each instance the event targeted is reported on its own in the event log.
Editing a Running Job
Editing a job on a running instance
The job editor opens from Edit Job on a job's node in the workflow diagram. Opened from the Workflow View diagram, a job switcher moves it between the jobs of that workflow instance; opened from Job View, it edits only the job you opened, with no switcher. It edits that instance, not the workflow definition — see Push Changes to Workflow to promote an edit.
The editor shows the job's custom fields. A Custom Fields section lists your tenant's definitions with this instance's values, and you can correct one on a run that is already under way. Earlier builds showed the section in the workflow editor only, so a built job's custom fields were invisible here.
A field marked required is enforced on an instance save only if the instance was built with it: clearing its value is refused. The instance's values are fixed when the workflow is built, so a definition made required after that build has no value here to check — and refusing the save would block an unrelated edit the platform is willing to accept.
A job whose load fails can be opened again. If the job's data can't be fetched, the editor closes and reports "Failed to load job: …". Picking the same job again retries it; earlier builds left the editor pointing at that job, so re-selecting it did nothing at all and the job looked permanently unopenable — the only way through was to open a different job first, or to dismiss the message. Dismissing the message now only dismisses it.
The Job Name is read-only here: renaming a job belongs to the workflow definition.
A container job's Sub-Workflow is read-only here, as a job's Connection is. A Workflow Container instance runs the sub-workflow it was built with: to run a different one, change Sub-Workflow on the job definition and rebuild the workflow. A change to it on a job instance is refused — "The sub-workflow cannot be changed on a job instance. Change it on the job definition and rebuild the workflow."
The Events tab is editable here. You can add, change and remove a job's events on a run already under way — to add a notification to tonight's run of a job without touching the definition, for instance. The tab was previously read-only in this editor.
Three things about it are particular to an instance:
- It shows this instance's own events, already narrowed to the frequency the instance was built for. The workflow editor's Events tab lists every frequency's events; this one lists the ones that can actually fire on this run.
- Events are not carried by Push. Because the list is narrowed to one frequency, writing it over the definition would delete every other frequency's events — so the definition is left alone, and an edit to events alone does not offer Push.
- Save names an incomplete event rather than rejecting the form. An event card with nothing chosen reports "Event 2: Choose the event to fire", and a Range comparison with no End Range reports "Event 2: enter an End Range for the Range comparison". The number is the card's position on the tab, so you know which one to open.
Events are sent only when the tab actually differs from what it loaded, so an unrelated save does not disturb them.
Each of a job's events is now recognised by what it fires rather than by its position in the list, so the platform can tell an event it has already delivered from a new one. Editing the events of a job that has already reached a terminal status therefore delivers only what you changed:
- An event you left alone is not re-sent, wherever it ends up in the list.
- Reordering events sends nothing at all.
- An event you edited or added gets delivered once, and is never given a value cached from the event it replaced.
Earlier builds keyed each event by its list position and renumbered the whole set on any edit, so
every event on the job looked new. Editing the events of a job that had finished — most visibly a
Failed job whose terminal events had not all landed — re-sent every one of them: duplicate
notifications, a duplicate $JOB:ADD, and so on.
One carry-over. A job that was already finished but not fully settled when this shipped still carries the old keying, so a first edit of one of those can re-send its events once. Jobs from any run after the upgrade are unaffected.
A refresh that fails after the editor is open keeps your edits. The editor re-reads the job immediately before saving. If that read fails, the dialog stays open with your edits intact and reports "Could not refresh job data before saving — please try again", so you can retry Save. Earlier builds closed the dialog as the save attempt unwound and discarded the edits. A background refresh that fails while nothing is in flight is silent, because the copy you're editing is intact and nothing is being asked of you.
Changing Success Reruns on a running job
You can change a job's Success Reruns on the instance, on the editor's Frequencies tab. What the change does to a cycle already under way is described in Editing reruns on a running job. These changes are refused before anything is written, and the save reports why, after Save failed:
| The change | What you see |
|---|---|
| A change that keeps Success Reruns on, on a job that has reached a final status and whose reruns have ended, when no container job above it can still start it again | "Success Reruns cannot be changed on job …: it is … and its reruns have ended. Rebuild the workflow, or change Success Reruns on the job definition." Nothing would run the job again. Turning reruns off is accepted. A failed job that is still part of a rerun cycle can still be changed, and so can a job inside a container that will run its nested workflow again. |
| The same change on a finished job inside a running container whose own reruns end with its current run — it is on its last run by Maximum Runs, or its latest start time or latest runtime has passed | The same message, ending "… and its container job's reruns end with the container's current run, so this workflow will not run again. …" A container that can still retry after a failure, before its latest start time, can still run the job again, so the change is accepted. |
| The same change on a finished job whose finished nested workflow is no longer loaded by the platform, as after a restart | The same message, ending "… and its finished workflow is no longer loaded, so the next container run builds a new workflow instead of rerunning this one. …" The change would be written to a run that is not used again. |
Restart Offset with no Maximum Runs and a Latest Runtime Offset of 00:00 | "Invalid job instance edit: Restart Offset reruns need a Maximum Runs or a Latest Runtime Offset (00:00 means no limit)". Without one of the two, the job would rerun without end. |
| New instance times that would move a waiting job's next rerun after its latest start time | "Invalid job instance edit: The next rerun would start at …, after the job's latest start time …. Choose an earlier time or move the latest start time." The two times are shown in UTC. A latest start time you change in the same save is the one checked. |
| A latest start time moved earlier than the rerun a waiting job has already scheduled | "Invalid job instance edit: The next rerun starts at …, after the new latest start time …. Choose a later latest start time." The two times are shown in UTC. |
| A latest start time moved earlier than the next failure retry of a job waiting to retry | "Invalid job instance edit: The next failure retry starts at …, after the new latest start time …. Choose a later latest start time." The two times are shown in UTC. |
| A changed Latest Runtime Offset on a run whose schedule date or workflow instance cannot be read | "Invalid job instance edit: Cannot resolve the Latest Runtime Offset: …", with the reason. The workflow instance may have been deleted. |
Times in these messages read like 2026-10-22 14:30:00 UTC.
Earlier builds accepted all of these. The three Success Reruns refusals left the job looking as if it would rerun when nothing would start it, and could keep its workflow In Process; the first also refused a change on a job that a container would still run again. The Restart Offset one could leave a job rerunning without a limit. The three latest-start refusals moved the rerun or the retry past the job's latest start time, so the job was marked Missed Start Time at that deadline and the rerun or retry was lost. The last could be accepted without taking effect, or fail with a server error.
A job with no Maximum Runs and a latest runtime shows a blank field. It has no run limit and
reruns until that time. The Latest Runtime Offset field reads 00:00 = no limit beneath it.
A job with neither limit shows 1, because that is what the run does: it ends its reruns at its
next success. The detail panel's Summary tab shows the same Maximum Runs, and saving the
editor stores the 1 it shows. Earlier builds showed such a job with a blank field and no
Maximum Runs row on Summary, which read as unlimited, and refused to save the blank field.
You can clear Maximum Runs on a job instance. Empty the field and save, and the run has no run
limit: it reruns until its Latest Runtime Offset. A Latest Runtime Offset of 00:00 with no
Maximum Runs is still refused, as in the table above. Earlier builds put 1 back in a field you
emptied. On the workflow definition, Maximum Runs is still required.
The editor shows the Latest Runtime Offset you typed. The offset is stored with the run as you
entered it, so reopening the editor shows the same value, and
Push Changes to Workflow writes that value to the definition. A run with
no latest runtime shows 00:00. A run built before this change has no stored offset, so the editor
works it out from the stored time, and the value shown can differ from the one typed. Building the
date again stores it.
A Latest Runtime Offset of 00:00 means no latest runtime. The job reruns until it reaches
Maximum Runs. This applies to an offset you enter on the instance and to one the build reads from
the definition. Earlier builds read 00:00 as the schedule's start time itself, so a job with that
setting never reran.
Push Changes
Push Changes to Workflow
Editing a job on a running instance normally changes that instance only — the workflow definition every future build comes from is untouched. Push Changes to Workflow is how you promote such an edit: it writes your change into the master workflow definition, so every future build uses it.
It sits in the job editor's footer, beside Cancel and Save. The two are independent and can be done in either order or on their own: Save writes the instance, Push writes the definition, and pushing neither saves the instance nor closes the editor.
It confirms first, in a Push Changes to Workflow dialog, because the definition is shared:
"This copies the job's task settings, tags and custom fields to the master workflow definition. All
future builds of this workflow will use these values. Other changes stay on this job." Confirming
(Push Changes) mints a new workflow version, with the change description Pushed edits from job "<job name>" — so the promotion is visible in the workflow's version history like any other
edit. See Versions and deployments.
What a push carries
A push carries three things, and nothing else:
| Carried | Stays on the instance |
|---|---|
| The task settings (the job's task definition), its tags and its custom fields | Everything else: frequencies and their timings, priority, failure retries and success reruns, properties, dependencies, the agent assignment and pool, documentation, whether the job is disabled, and the job's events |
Edit anything else on an instance and Save keeps it on that instance; to change it for future builds, change it on the workflow itself.
The batch user stays the definition's. A push writes your task settings with the definition's own batch user kept in place, so the credential the definition runs as cannot drift from its saved connection.
Custom fields are pushed field by field, rather than as a set. The instance's values are fixed when the workflow is built, so a definition an administrator added since has a value on the workflow and no value here — replacing the whole set would delete it without saying so. Each field you actually touched is written, and clearing one on the instance does clear it on the definition. Clearing a required field this way is refused when the push saves the workflow.
When the action is available
Push is offered when the job actually differs from its definition in something a push carries — and that is deliberately narrower than "something was edited":
| Situation | Push |
|---|---|
| You edited the task settings or custom fields in this window (tags are read-only in this editor) | Available |
| You edited one of them in an earlier session and saved to the instance | Available |
| You just pushed successfully | Not available |
| You edited a field and then edited it back | Not available |
| You edited only something a push does not carry | Not available |
| The definition was edited after this instance was built, and you changed nothing | Not available |
That last row is the one worth understanding. A definition that has simply moved on since the build is not operator divergence, and offering to push it would write the instance's build-time values over the newer definition. So Push follows what you changed on this instance, narrowed to what the definition still disagrees with.
When Push is not available, the editor says why, beside the footer buttons:
| Beside the buttons | Means |
|---|---|
| These changes have already been pushed to the workflow. | You pushed these edits already. |
| Only task settings, tags and custom fields are pushed to the workflow. Save keeps your other changes on this job. | You changed only something a push does not carry. |
| There are no changes to push to the workflow. | Nothing you changed differs from the definition. |
| The workflow definition could not be loaded, so Push cannot check what would change. | An edit from an earlier session cannot be checked against the definition right now. An edit you make in this window still enables Push. |
| Job "…" was not found in the workflow definition. | The job has been removed from, or renamed in, the definition, so there is nothing to push it into. |
Push works per field, not per value. If you edited the task settings or tags on the instance and someone else edited a different part of the same field on the definition in the meantime, your push replaces the whole field — and their change goes with it. Custom fields are the exception — they are carried one field at a time, as described above.
Earlier builds gated Push on the current editor window alone. Reopening a job you had already edited and saved showed the action unavailable even though the instance still genuinely differed. Earlier builds also pushed far more — frequency settings, properties, dependencies, the agent assignment and documentation — and offered Push for an edit to any of them.
What you may see
| Message | Means |
|---|---|
| Changes pushed to workflow | A new workflow version was written, carrying the task settings, tags and custom fields you changed. |
| Some changes pushed to workflow. Not pushed: … | A new workflow version was written, but some of your changes could not be carried; the message names them. |
| This job already matches the workflow definition — nothing to push | Nothing needed writing. No version is minted for an identical configuration. |
| The workflow definition changed since it was loaded. Reopen the job and try again. | Someone else saved the definition while your editor was open. Reopen the job so you are working from the current definition, then push again. |
| Could not refresh job data before pushing — please try again | The instance could not be re-read immediately before the push. Nothing was written. |
The push always re-reads the instance first, so it writes the instance's current values rather than whatever the editor was opened with — which matters because a push can fire with no local edit at all.
Pushing from a numbered copy works. A copy such as Load.EU$0001 — added beside a live
Load.EU, see A live instance gets a copy, not a conflict —
pushes to the job it is a copy of in the definition.