Properties
- Synopsis
- Full Details
In briefA property is a named value that jobs read at run time through a token such as
[[OI.Region]], so one workflow can run against different paths, environments or dates without
being rebuilt. Properties belong to a workspace and can be encrypted to hold secrets.
WhereDesign › Toolkit › the Properties tab. New Property opens the editor dialog; a row's menu has Edit (or View) and Delete.
When
- A value — a path, an environment name, a threshold for a script — is reused across jobs, or changes between environments.
- A job needs a credential: keep it in an encrypted property rather than in a job parameter.
To find, filter or group related jobs, use a tag instead.
For a value a job computes as it runs, use an expression or write it onto the
run with a $PROPERTY event instead.
How
- On the Properties tab, select New Property, give it a name and a value, switch Encrypted on for a secret, and save.
- Reference it from a job parameter as
[[Name]]or[[OI.Name]].
The full steps are on Manage properties, calendars, and tags.
- A token that does not resolve fails a job parameter at dispatch, but an event a job fires and a notification still go out with that token left unresolved and the other tokens filled in. An event submitted from outside a job fails instead, and so does an event that would create a property whose name holds an unresolved token.
[[MI.Name]]reads a machine property of the job's agent, and[[MI.Name.AGENT01]]another agent's. A$PROPERTYevent with anMI.name writes one.[[SSI.…]]and[[SJI.…]]read the parent workflow and the container job of a sub-workflow, in a job parameter or an expression dependency.- A value can hold any text, including a URL.
- An empty value is a real, unset value that resolves to the empty string. To empty an encrypted property, use Clear stored value.
- Names beginning with
$belong to the platform. Date and time tokens take a format and an offset, as in$SCHEDULE DATE mm/dd/yy(-1dd). - An event's schedule date and calendar dates ignore a time of day after the date, so
[[$NOW]]works there.
- Properties have no Cross Reference, and their Delete runs no reference check. Confirm a property is unused before you remove it.
- Don't create two properties whose names differ only in case: a token naming either one fails.
- An encrypted value is never returned or exported. Turning Encrypted off needs a new value, and an overwriting import that would land an empty value on an encrypted property is refused.
- A token that brings a comma into an event field fails the event, except a tag list in
Tags. A name that brings a
,or;into Tags fails it too, and a$CONSOLE:DISPLAYmessage keeps only the commas you type.
Task walkthrough: Manage properties, calendars, and tags. This page is the full configuration and troubleshooting reference.
A property carries a value a job reads at run time, so the same workflow can run against different paths, environments, or dates without being rebuilt. Properties are scoped to a workspace. To label jobs so you can group and search them instead, use a tag: tags are global, and behave differently.
- Property Fields
- Tokens
- When Tokens Resolve
- Events from Outside
- Writing to a Run
- Date and Time Tokens
Property Fields
Where properties are managed
Properties live in the Toolkit, on the Properties tab, and are created, edited and viewed in one dialog over the list.
Properties are the one Toolkit type with no Cross Reference action. A property is named by a token written as free text in many places rather than held as a stored reference, so Continuum offers no reference lookup for it — and its Delete goes straight to the confirmation without a reference check. Confirm a property is unused before you remove one: a token naming a property that does not exist fails the job at dispatch.
Properties (workspace-scoped)
A property is a named key/value used to parameterize jobs — for example, a path or an environment name reused across jobs.
| Field | Notes |
|---|---|
name | Unique property name. 3–255 characters, following the platform naming rules — $TempFolder and Payroll/EU are both valid. |
value | The value. May be empty — see below. Any text is accepted, including a URL such as https://example.com/api. |
encrypted | When true, the value is stored encrypted and is not returned when read back. |
description | Optional. |
- Properties are workspace-scoped (default to the General workspace).
- Don't create two properties whose names differ only in case, such as
RegionandREGION: both can be saved, but a token naming either one then fails to resolve, and a job using it ends in Initialization Error. - An encrypted property's value reads back empty by design — that is not data loss. Use encrypted properties for secrets rather than putting them in job parameters.
- An encrypted value is never exported. A property carried in an automation bundle arrives with an empty value and has to be set again in the target environment.
An empty value, and clearing one
An empty value is a legitimate state, and it means this optional setting is unset. A token naming such a property resolves to the empty string — it does not go unresolved and it does not fail the job.
Empty is not the same as absent, and the difference matters more than it looks:
| The property | A token naming it resolves to | If it can't resolve |
|---|---|---|
| exists, value empty | the empty string — -P [[OI.PASSWORD]] becomes -P | n/a — it resolved |
| does not exist | nothing | The job fails at dispatch; in an event, the field keeps its [[…]] text |
So delete a property you no longer want and empty a property whose setting is simply unset — they are
not interchangeable, and only one of them fails loudly when you get it wrong. A value is still
required to be present: a create with no value at all is rejected.
The Properties list distinguishes the states that used to look identical:
| List shows | Meaning |
|---|---|
| the value | A plaintext property with a value. |
| (empty) | A plaintext property whose value is deliberately empty. |
| •••••• | An encrypted property — the value is never sent to the browser. |
| — | The value was withheld: a deleted property. |
Clearing an encrypted property's value is its own action. In the property's dialog, use Clear stored value — then save. (Keep stored value backs out.) The value field is disabled while a clear is pending, so it cannot show something the save would discard.
An encrypted value is never returned, so the value field loads blank. A form that submitted what it was showing would send an empty value on every ordinary save — and storing that would replace a secret that exists nowhere else. So a blank on an ordinary update is refused with an error telling you to send a new value or clear it deliberately. A blank you left alone means "keep it".
Clearing the value does not un-encrypt the property: it keeps its Encrypted flag and holds an encrypted empty value — the same state creating an encrypted property with an empty value produces.
A stored encrypted value is never decrypted, so switching Encrypted off is not a way to read one back. The save needs a new value to store as plaintext in its place, and Save stays unavailable until you type one — the field reads Enter the value to store unencrypted., under a note headed Enter a new value to turn encryption off. The value you type is then visible to anyone who can view the property, including in the properties list and in reports.
The stored ciphertext is left untouched by a refused attempt, so nothing is lost by trying. Through
the API the same rule is a 400 naming value: encrypted: false with no value is rejected,
and so is any non-boolean encrypted.
Clear stored value is not an alternative route here — a clear keeps the property encrypted, so the action is hidden while Encrypted is switched off. Turning encryption off and emptying a value are two different things, and each has its own way in.
Write access to a secret is not read access, and that is the point of the rule: before it, anyone who could edit a property could turn its flag off and read back a credential they had never been told.
Importing property values
Import payloads carry property values in plaintext, and a value flagged encrypted: true is
encrypted at rest by the import — exactly as it would be if the property were created through the
API. Earlier builds stored the plaintext flagged as ciphertext, and because every read path masks an
encrypted value, the corruption was invisible.
An export never carries an encrypted value; it emits an empty one in its place, expecting you to re-enter the secret before importing. So an overwriting import that would land an empty value on a property already holding an encrypted one is refused, naming the property. Supply the value it should hold, or remove it from the import. A non-overwriting import is unaffected — it is not writing to that row.
Finding a property by its value
The Properties list shows a Value column, and you can filter on it — useful for the question "which property is set to this path?" rather than "what is this property set to?". The filter matches any part of the value and ignores case, and the term is capped at 100 characters.
Two rows are deliberately absent from the results, and both matter if you are relying on the filter to be exhaustive:
- Encrypted properties. Their value is never shown and never searched. They are excluded from a filtered result rather than shown as non-matching, so a filter can never be used to confirm what an encrypted value is by process of elimination.
- Deleted properties. A deleted property withholds its value whether it was encrypted or not, and the filter skips it for the same reason.
A property that is not marked encrypted has its value visible in the list and searchable by anyone who can read properties in that workspace. If a value should not be read back, mark the property encrypted when you create it — the flag is what withholds the value, not obscurity.
Tokens
Referencing a property from a job
Job parameters can carry property tokens, which are resolved as the job is dispatched. Write a
token as [[Name]] or {{Name}}. The events a job or workflow fires resolve tokens too, but at
a different moment and under different rules — see
When tokens are resolved (on the When Tokens Resolve tab).
A single string uses one delimiter pair, not both. If the string contains [[ anywhere, only
[[ … ]] tokens resolve and any {{ … }} is left exactly as written. So in
[[Path]] and {{Other}}, only Path resolves. Be consistent within a value.
In the Instance Properties or Schedule Properties list of an event a job or workflow fires,
each name and each value counts as its own string, so A=[[OI.X]];B={{OI.Y}} resolves both.
Computing a value instead of looking one up
A token whose body begins with = is an expression: the platform computes the answer rather
than looking a name up.
[[= ToInt([[JI.RetryCount]]) + 1 ]]
[[= ToUpper([[OI.Environment]]) ]]
Arithmetic, comparisons, string slicing and case folding, duration maths, conversions, and nested evaluation are all available, over literals and over the properties a token resolves. Expressions are evaluated at the same moments an ordinary token is, and a failed expression costs the same as a failed name — see Using expressions with dependencies and properties for the operators, the precedence rules, and the failure behavior.
Earlier builds refused a [[= … ]] token outright. An expression that attempts an assignment
is still refused, so nothing an expression computes can change a property, a threshold, or a
resource count.
Scopes
A token can name the scope it's asking about: [[Scope.Name]]. Without a scope, the name is looked
up as a global property — unless it is a $ system name, which is routed to the scope that owns
it instead.
| Scope | What it reads |
|---|---|
OI | A global (workspace) property. [[RI.Instance.Name]] reads the same thing: the instance name after RI is ignored, so it means [[OI.Name]]. |
SI | The current schedule (workflow) instance. This is where a schedule instance's own properties resolve. |
JI | The current job instance. |
MI | The agent the job is running on: its $MACHINE NAME, and the machine properties you set on it. [[MI.Name.AGENT01]] reads agent AGENT01's property instead. |
TH | A named threshold's current value. |
RM | A named resource's total units — its maximum. |
RU | A named resource's units currently in use, across every environment. A resource's total is one pool that all your environments share — see One total for every environment. |
SSI | The parent workflow instance of a sub-workflow instance — the workflow that holds its container job. In a job parameter and an expression dependency only; see below. |
SJI | The container job that built the sub-workflow instance. In a job parameter and an expression dependency only; see below. |
Some scopes accept extra dot-separated parts that say which instance to read:
| Scope | Extra parts accepted |
|---|---|
SI | Up to two — schedule date, schedule name |
JI | Up to three — schedule date, schedule name, job name |
MI | One — machine name |
OI, TH, RU, RM | None. A stray part is a parse error, not an ignored suffix. |
SSI and SJI look one level up from a job inside a sub-workflow. [[SSI.X]] reads X as an
SI token on the workflow instance that holds the container job, and [[SJI.X]] reads it as a
JI token on the container job itself. They never look further up than the immediate parent.
- They resolve in a job parameter, as the job is dispatched, and in an
expression dependency. They are not resolved in a job's
or workflow's events, where a
[[SSI.…]]or[[SJI.…]]token keeps its written text. - In a workflow that is not a sub-workflow there is no parent, so the token does not resolve. In a job parameter that fails the job, as any unresolved parameter token does.
- Extra parts that name a different instance, such as
[[SSI.X.date.workflow]], are refused, as they are forSIandJI. - The property picker does not offer them; type them.
Earlier builds accepted these tokens but resolved neither, so a migrated job that used one ended in Initialization Error without being dispatched.
In a $PROPERTY event the same two scopes name a property to write — see
Writing a property onto a running instance (on the Writing to a Run tab).
CI is a Vision-only scope, not a property scopeA Vision trigger action's values may carry [[CI.$…]] Card tokens — [[CI.$CARD NAME]],
[[CI.$CARD STATUS]] and five more. The property selector offers them as a Card group when you
are editing a Vision action, which is the only place they mean anything: Vision sends the firing
card's values with the action's event, which resolves them as it is processed, and nothing else in
the platform supplies them. They are not a property scope, they do not appear in the table above, and a CI
token in a job event or a notification is not substituted. See
Vision triggers.
Addressing a different instance — another schedule or another job — isn't supported, and is
refused rather than silently resolving to the current one. The agent scope is the exception: a
machine property can be read from another agent by naming it, as in
[[MI.EMAIL.PROD01]]. A system name is read only for the job's own agent, so
[[MI.$MACHINE NAME.PROD01]] does not resolve.
Which MI system names answer depends on what raised the message. $MACHINE NAME resolves wherever the
platform knows which agent the job is on.
$MACHINE OPER STATUS resolves in an agent notification about an operator mark, where the mark
is the event — see
what an agent notification can resolve.
$MACHINE RUNNING JOBS and $MACHINE NET STATUS don't resolve anywhere.
Machine properties in a token
Every agent can carry its own list of name/value machine properties, set in its
Machine Properties dialog or written by a
$PROPERTY event. A token reads one:
[[MI.Name]]readsNamefrom the job's own agent.[[MI.Name.AGENT01]]readsNamefrom the agent calledAGENT01, matched by its exact name, ignoring case and surrounding spaces. When no agent, or more than one agent, has that name, the token does not resolve.
The property name is matched ignoring case. A name that contains a dot can be read only with the
name in double quotes, as in [[MI."app.home"]].
Which agent is the job's own depends on where the token is:
| Where the token is | The job's own agent |
|---|---|
| A job parameter, the command line or a runner template | The agent the job is dispatched to: its agent, the backup agent chosen, or the member a legacy agent group picked. A job assigned to a specific Universal Agent reads that agent. A job on a Universal Agent pool has none, so only the [[MI.Name.AGENT01]] form resolves |
| An expression dependency | Only a job assigned to a specific agent with no backup agents has one. For any other job only the [[MI.Name.AGENT01]] form resolves |
| An event a job fires | The agent the job ran on |
| An event a workflow fires | None, so only the [[MI.Name.AGENT01]] form resolves |
| A Job notification | The agent the job ran on, with its properties captured when the job's status changed. The [[MI.Name.AGENT01]] form does not resolve there. See Notifications |
| An event submitted from Self Service, the API, the CLI, a webhook or a legacy agent | None. No MI token resolves, and the event fails, as for any token it cannot fill in |
A property the agent does not have fails like any unresolved token: in a job parameter the job goes to Initialization Error, and in a fired event the token keeps its text. If the platform cannot read the agent's properties at dispatch, the job is not failed: its dispatch is tried again.
$MACHINE … system names are never answered by a machine property: a machine property cannot be
given a system name.
System properties
Names beginning with $ are system-managed — the platform supplies the value, and you don't
create a property for them. They're written in upper case with spaces ($JOB NAME,
$MASTER SCHEDULE NAME) and matched case-insensitively.
Most system names must match exactly: $JOB NAMESPACE is not a variant of $JOB NAME and won't
resolve as one.
Every system name, what it resolves to, and where it can be used is listed in System properties.
$EST RUN TIME and $MAX RUN TIME render as HH:mm:ss text — a duration, not a count of
minutes — and 0 renders 00:01:00 rather than 00:00:00. So a comparison against either has to
be written against text: > "00:10:00", never > 10, which is a type error. See
Expression dependencies for what that does to a job.
Where either token is offered from a property picker, the picker's row now says so, so you don't have to find this out from a held job.
An unqualified $ name isn't a global
Writing a system name with no scope doesn't make it one. [[$JOB NAME]] is read in the job
scope, not looked up among your globals, because the platform routes a bare $ name to the scope
that owns it — that is what makes the short form work at all.
A $ name the platform doesn't recognise is routed by its prefix instead:
| Prefix | Scope it's read in |
|---|---|
$MASTER SCHEDULE, $SCHEDULE | SI — the schedule instance |
$MASTER JOB, $JOB, $MACHINE, $FREQUENCY | JI — the job instance |
$ nameA global of your own called $JOB REPORT can't be read as [[$JOB REPORT]] — that token is
routed to the job scope, which has no such name, so it comes back unresolved. Name it without the
$, or address it explicitly as [[OI.$JOB REPORT]]. The $ prefix belongs to the platform.
When Tokens Resolve
When tokens are resolved
There are four moments a token can be resolved, and they answer differently on purpose.
| Where the token is | Resolved | If it can't be resolved |
|---|---|---|
| A job parameter | As the job is dispatched | The job fails. A parameter is an instruction to a machine, so running something nobody asked for would be worse. |
| An event a job or workflow fires | As the event fires | The event still fires. The token that failed stays exactly as you authored it, and every other token in the same field still resolves. |
| A notification template | As the notification is sent | The notification still goes out, and that token renders as its own bare name. See Template tokens. |
| An event raised from outside a job — the self-service portal, the API, the CLI, a webhook, or a legacy agent | As the event is processed, just before it is carried out | The event fails, naming the token. A legacy agent's line is refused before it becomes an event, so it never reaches the event log. See An event raised from outside a job (on the Events from Outside tab). |
That difference matters. An event fired by a job or a notification is a message about a job, so a
message body naming a property nobody defined must not take down the job it is reporting on, and one
bad token in a $JOB:ADD event must not quietly stop downstream work from being scheduled. An event
somebody submitted is the opposite case: nothing is already under way for it to interrupt, and
the request itself is what the token was meant to configure.
Two things follow from "the message always goes out" — which is the rule for an event a job or workflow fires and for a notification, not for an event somebody submitted:
- The unit is the token, not the field. A single bad token fails on its own, and every other
substitution in the same field still resolves. An email body written as
[[JI.$JOB NAME]] [[$JOBNAME]] [[JI.$JOBID]]— where$JOBNAMEis a misspelling of$JOB NAME— is sent with the job name and the job ID filled in and[[$JOBNAME]]left as written. The same holds in a notification template. - An unresolved value is left visibly unresolved. In an event field the failed token keeps its
[[…]], so an event you find in the event log still reads as a misconfigured token instead of looking like text somebody meant to type. A notification renders the token's name without its delimiters, which reads the same way to the person holding the page. For an expression the text inside the delimiters includes the=, so in a notification a failed[[= 1 @@ 2 ]]renders as= 1 @@ 2. - A few failures still leave the whole field as authored. A token that refers to itself in a loop, a field that uses up the resolution budget, and an expression that attempts an assignment fail the whole field, so that field is sent exactly as you wrote it. The event still fires.
- A name the event creates is the exception. If a token in the property name of a
$PROPERTY:ADDdoes not resolve, the event is refused rather than creating a property named with the token's text. The same holds for a property name in the Instance Properties or Schedule Properties list of$JOB:ADD,$JOB:ADDHLD,$SCHEDULE:BUILDand$SCHEDULE:BUILDHLD:[[OI.MISSING]]_RUN=1refuses the event rather than giving the added job or workflow a property called[[OI.MISSING]]_RUN. A token that fails in a value of that list still leaves its text in place. A refused event is recorded asFAILEDin the event log, and nothing is added.$PROPERTY:SETand$PROPERTY:DELETEonly match properties that already exist, so they still go ahead.
An event a job or workflow fires never carries the value of an encrypted property. It is
replaced with a mask wherever it would have appeared, including when a plain property's value
references an encrypted one — so $PROPERTY:SET,TARGET,[[OI.DB_PASSWORD]] fired from a job sets the
target property to the mask, not to the password.
An event submitted from the portal, the API, the CLI, a webhook or an agent is handled differently again: it is refused rather than masked, except in the one field that may carry a secret — see An event raised from outside a job (on the Events from Outside tab).
A notification is the other way round. The same token in a notification template resolves to the real stored value and the message carries it — see Notifications. The two seams differ here, as they do on when tokens resolve and on what a failed one does.
In an event a job fires, values are pinned to the moment the event fired. If delivery is retried later, the payload built at fire time is re-used verbatim, so a clock token, a property somebody edited in between, or a live threshold or resource reading can't make the retry say something different from the original. The exception is a payload in which a token did not resolve: it is not pinned, so a retry resolves it again. An event submitted from outside a job is pinned the other way — the authored text is what is stored, and a retry resolves it again.
What a job or workflow event can resolve
At event time the job's own row is the source, so tokens report what actually happened rather than
what was assumed at dispatch — $JOB STATUS is the status that fired the event, and the end time,
run time and termination text carry real values.
| Scope | Names available |
|---|---|
JI | $JOB NAME, $JOBID, $JOBID LONG, $JOBID CMP, $JOB STATUS, $JOB TERMINATION, $JOB STARTTIME, $JOB ENDTIME, $ACTUAL RUN TIME, $MAX RUN TIME, $EST RUN TIME, $FREQUENCY NAME, $MACHINE NAME, $RESTART STEP once the job has been restarted on a step, and the five $ARRIVED … names on a job that matched a file |
MI | $MACHINE NAME — the agent that actually ran the job, not the one configured — and that agent's machine properties. In a workflow event, only another agent's, named in the token |
SI | $SCHEDULE NAME, $MASTER SCHEDULE NAME, $SCHEDULE ID, $SCHEDULE INST, $SCHEDULE DATE, $SCHEDULE DATEMS, $SKD STATUS |
A workflow event has no job in scope, so it answers only the SI names; job-scoped
names in a workflow event fall through like any other unresolved name. Anything not listed above is
looked up as an ordinary property, so your own globals and instance properties work as they do
elsewhere.
$SCHEDULE INST is the run, not the rebuild$SCHEDULE INST reports which run of a schedule instance this is for the date — the same number
the $nnnn suffix shows, 1 for anything not repeat-built. It is not the build number, which counts
rebuilds of one run. See
Building one instance more than once for a date.
A status notification's payload used to seed it from the build number instead, so a job's
command line and a notification about the same run could report different numbers for one token. All
three now answer with the run. A rebuilt first run — run 1, build 2 — therefore reports 1 in a
notification where it used to report 2.
A job that never started renders N/A for its start and end times rather than leaving the token
standing, and a job that finished OK renders an empty termination — those are values, not
failures to resolve. $JOB STATUS CATEGORY is not available at event time and does not resolve.
The file a File Arrival job found
A File Arrival job — Windows or UNIX —
records the path it actually matched, and five JI names carry it into the events and notifications
that job fires. A pattern such as /data/inbound/*.csv can match any of a thousand files; these are
how a later job is told which.
For a matched /data/inbound/ledger.csv:
| Name | Value | What it is |
|---|---|---|
$ARRIVED FILE NAME | /data/inbound/ledger.csv | The whole path, exactly as the agent reported it |
$ARRIVED FILE PATH | /data/inbound | The directory part |
$ARRIVED SHORT FILE NAME | ledger.csv | The last segment |
$ARRIVED BASE FILE NAME | ledger | The last segment without its extension |
$ARRIVED FILE EXTENSION | .csv | The extension, leading dot included |
They are JI names like any other, so [[$ARRIVED SHORT FILE NAME]] and
[[JI.$ARRIVED SHORT FILE NAME]] are the same token.
An empty part is a real answer, not a failure: a path ending in a separator has no short name, and a file with no dot in its name has no extension, so those render as nothing at all.
A job that did not report a file — anything but a File Arrival job, a File Arrival job that failed to match, a run cleared by a restart — supplies no value for any of the five. In an event or a notification the token then renders as its own bare name, exactly as any other unresolved name does there. That is deliberate: there is no file, and a blank would read as though there were one and it had no name.
The four derived parts are worked out only for the Windows and UNIX File Arrival job types,
because the split depends on which platform's path rules apply. A file reported by anything else
resolves $ARRIVED FILE NAME and nothing more.
Windows paths split on either \ or /. A file at a drive root keeps the separator
(C:\ledger.csv → C:\), and a UNC path keeps its share (\\srv\share\ledger.csv →
\\srv\share).
Events from Outside
An event raised from outside a job
An event nobody's job fired — one submitted from the self-service
portal, the API, the CLI, a webhook, or written into a
legacy agent's MSGIN directory — resolves its [[…]] tokens too, as the
event is processed. So a self-service button can carry $JOB:ADD,[[$DATE]],DAILY,MYJOB and a script
on an agent can name a schedule with [[OI.REGION]], both of which used to arrive as their literal
text and be refused or applied as the characters themselves.
Resolution is strict here: a token that does not resolve fails the event. A lenient render would
turn a mistyped [[OI.REGON]] into the text OI.REGON, which looks like a perfectly valid value
and would be applied to real work. The failure names the token as you wrote it and the field it
sat in, and never a resolved value — the message is kept in the event log, where
more people can read it than can read the properties it resolved. A line from a legacy
agent is checked earlier: a token that does
not resolve refuses the line before it becomes an event, so it does not appear in the event log.
| The token | What happens |
|---|---|
| A global property that exists | Resolves to its value. |
[[$DATE]], [[$TIME]], [[$NOW]] and their formatted forms | Resolve from the clock. |
| A name no global property has | The event fails: no global property with that name exists. |
A job, schedule instance or machine scoped token (JI, SI, MI, TH, RM, RU) | The event fails. Such an event has no job in scope to answer them — and that is the point of the message, rather than a silent empty value. |
| A token in the event type position of a command line | Refused: the event type must be written literally, because it is what the event is routed and validated as. |
The stored payload keeps the text you authored. Nothing resolved is written to the event record,
so the event log shows a submitted event as the author wrote it, and a retry or
replay resolves it again rather than re-using an earlier result. One consequence worth knowing:
[[$DATE]] in an event retried tomorrow means tomorrow, exactly as it would if the caller had
submitted it again today. A legacy agent's line is the exception: it is resolved once, before it is
submitted, and the event acts on that result while the record shows the line as written, so an
agent-raised event that carried a token cannot be replayed from its record — raise it again from the
machine.
A value that would break the field it lands in is refused. An event's fields are separated by
commas that cannot be escaped, so a resolved value carrying a comma into a positional field, or a
; into the properties field, fails the event with a message saying so instead of silently
decoding as an extra entry. Classic OpCon has no escape for these separators either: it splits the
value, so its fields shift, it gains an entry, or it fails. Each refusal ends with a sentence saying
which — for example Classic OpCon fails this event (Incorrect number of fields).
Two fields take the rest of the line, and each treats a substituted comma its own way:
tagskeeps it. Tags are separated by,or;, so a comma or semicolon that a global property or an expression brings in separates tags, and a property can carry a tag list.- The
$CONSOLE:DISPLAYmessage refuses it. A comma you type into the message is kept, but a comma that any value brings in — a property, an expression, a name, or text a job reported — fails the event, saying only a comma typed into that field is kept, because Classic OpCon fails a console message with any comma. An event such as$CONSOLE:DISPLAY,Failed: [[JI.$JOB TERMINATION]]is refused when the termination text holds a comma.
A name that brings a , or ; into tags is refused, though. A
Vision card token such as [[CI.$CARD FREQUENCY NAME]] is one name, never a
list, so a frequency named Month-End, Quarterly or Month-End; Quarterly would otherwise become
two tags nobody wrote. The event fails, saying a name substituted into the field contains , or
;, and that Classic OpCon splits tags on ; while Continuum splits them on , or ;.
The same refusal applies wherever an object's name is substituted into tags: a job, schedule,
machine or frequency name in a job or workflow event, the object name in a notification's OpCon Event
action, and a system variable such as the submitter's display name in a Self Service request. The
refusal names the Tags field rather than a position in the line. A job or workflow event refused
this way is recorded in the event log as FAILED, with the
reason, and nothing is applied. A notification's OpCon Event action fails its delivery attempt. A
comma or semicolon in a global property, an instance property, an expression or text you typed still
adds each tag.
In a job or workflow event, a name cannot add entries to properties or dates either. A job,
schedule, machine or frequency name that brings a ; into either field is refused the same way —
a job named ETL;RUN_USER=svc would otherwise add a property nobody wrote. A ; that a global or
instance property brings in still separates entries, so a property can carry a list of dates or
properties.
A property lookup that is temporarily unavailable is not your mistake. If the service that holds the properties cannot answer, the event fails as a temporary failure and stays replayable, so a retry can succeed. Only the event as written produces a permanent refusal.
In an event raised from outside a job, an encrypted property may appear in exactly one place:
the value of $PROPERTY:SET or $PROPERTY:ADD, written there as a single bare
[[OI.NAME]] reference with nothing else around it. Anywhere else — another field, an
expression over it, text either side of it — the event is refused, with the
same message every time so that nothing about the secret can be inferred from which rule caught it.
And the property it is copied into must itself be encrypted. $PROPERTY:SET refuses a plaintext
target, and so does $PROPERTY:ADD when the property already exists; when it does not,
$PROPERTY:ADD creates it encrypted. Otherwise
$PROPERTY:ADD,TMP,[[OI.SECRET]] would decant the secret into a property anyone who can read
properties can read, and [[OI.TMP]] would then pass every encrypted-value rule there is.
The copy is written as encrypted, not merely checked against an encrypted target. The target's Encrypted switch could be turned off between the check and the write — a window of a moment, but a real one, and the write would then have landed the secret in the clear. A value that came from an encrypted property is now written with its encryption asserted, so it is stored encrypted whatever the target's switch says by the time the write arrives. A plain value still leaves the target's switch alone.
An instance property can never hold one. A property written onto a workflow or job instance (on the Writing to a Run tab) has no encrypted form for the value to go into, so an event copying an encrypted property onto one is refused rather than storing it in the clear.
These rules now cover a notification's OpCon Event action as well. That channel renders its own
payload and submits the result, so it used to arrive past the point where the rules were applied —
and a notification action reading $PROPERTY:ADD,TMP,[[OI.DB_PASSWORD]] really did create a
plaintext TMP holding the decrypted password. The action now declares that the value came from an
encrypted property, and the same three rules apply to it. If you have such an action configured,
the plaintext property it already created still exists — the fix stops new ones being made, and
cannot reach back into one that was. Delete it, or turn its Encrypted switch on and re-enter the
value.
A tenant can change how [[$DATE]] renders everywhere by defining a global named $DATE — see
Date and time tokens (on the Date and Time Tokens tab). That is right for text a person reads and wrong for a
field a parser reads: an event's scheduleDate and dates fields are read month-first, so
05/09/2026 written for 5 September would land the job on 9 May.
Those two fields therefore always render with the built-in format and ignore the override. Every
other field still honours it. A suffixed form such as [[$DATE_EU]] has no built-in format to fall
back on, so in a date field it is refused rather than landed on the wrong day.
This now holds on every path that produces such an event. Three of them do, and each resolves its own tokens rather than being resolved a second time on submission — so each had to be fixed separately, and for a while they disagreed:
| The event is produced by | Hides the override |
|---|---|
| A submission from outside a job | Yes |
| A job or workflow firing one | Yes |
| A notification's OpCon Event action | Yes |
The notification channel was the last of the three, so a notification action was still putting 5 September's job on 9 May after the other two had been corrected. All three now hide the override and render the date in the default culture, because a built-in Short Date is only month-first in some cultures while the parser reading it is month-first in all of them.
A date format cannot come from an encrypted property. If the global that names the format is marked Encrypted, the token is refused rather than rendered — the date would otherwise be a function of a secret, computed with nothing recording that the secret had been read. A strict consumer refuses the event and says the format is encrypted; elsewhere the token degrades to its own name. The message names the property and never its value, and it is deliberately not the same message as a malformed format: an operator cannot open an encrypted value to hunt for a typo, so telling them to look for one would send them nowhere.
A date field accepts a date with a time of day
The schedule date of a job or schedule event, and the dates of a $CALENDAR:ADD, read the
date and ignore a time of day after it. So a token whose default format carries a time works there:
[[$NOW]] renders General Date, such as 10/16/2026 2:30:05 PM, and [[$JOB STARTTIME]] and
[[$JOB ENDTIME]] render yyyy/MM/dd hh:mm:ss. Each puts the event on that date.
The time is h:mm or h:mm:ss, with or without AM or PM, after a space. It must be a real time
of day: 1 to 12 with AM or PM, 0 to 23 without. A time that is not, such as
10/16/2026 25:00, is refused with the rest of the value. The refusal names the field, as in
"field 'scheduleDate' has an invalid date; expected CURRENT, a day offset (+1/-1), or a date (…,
optionally followed by a time)".
Earlier builds accepted a bare date only, so a Self Service button or any other event using
[[$NOW]] in its schedule date was refused, although CURRENT worked.
Everything in What a job or workflow event can resolve otherwise still applies to a job-fired event as before: its producer resolves the tokens and deliberately leaves some text literal, and it is not resolved a second time.
Writing to a Run
Writing a property onto a running instance
$PROPERTY:ADD, $PROPERTY:SET and $PROPERTY:DELETE write onto a global property, and also onto
a workflow instance or a job instance, so a job can record what it measured onto its own run
and a later job in the same run can read it back with [[JI.…]].
The target is named in the property-name field, with dot-separated parts:
| Name | What it writes to |
|---|---|
NAME, or OI.NAME | A global property, as before |
SI.NAME[.date[.workflow]] | A workflow instance's property |
JI.NAME[.date[.workflow[.job]]] | A job instance's property |
SSI.NAME[.date[.workflow]] | The parent workflow instance of a sub-workflow instance |
SJI.NAME[.date[.workflow]] | The container job that owns a sub-workflow instance |
MI.NAME[.machine] | An agent's machine property — see Writing a machine property |
The older spellings $TOKEN:ADD, $TOKEN:SET and $TOKEN:DELETE are accepted wherever an event is,
and are applied as the matching $PROPERTY event, under the same rules.
SSI and SJI in a $PROPERTY eventAs a token, [[SSI.X]] and [[SJI.X]] resolve in a job parameter and an expression dependency
only — see Scopes (on the Tokens tab). In a $PROPERTY
event they walk up from a sub-workflow instance to the parent workflow instance, or to the
container job that owns it. A
$PROPERTY:SET,SSI.X,… raised from a top-level workflow fails, because that workflow is not a
sub-workflow instance and so has no parent to walk up to.
SJI accepts a fifth (job) part for Classic compatibility and ignores it — the container job is
the target either way.
Leaving the trailing parts blank targets the run that raised the event. JI.DISK_PCT with
nothing after it is the triggering job instance; SI.DISK_PCT is the triggering workflow
instance. A part you skip is defaulted individually, in position, so
JI.DISK_PCT..NIGHTLY leaves the date blank — defaulted from the trigger — and names the
workflow NIGHTLY, with the job part left blank too. A blank job part in another workflow
instance means the job with the same name as the triggering job, which is how you write the same
value onto the same job in a different run.
That shorthand only works for an event a job or workflow fired, because only those carry the
instance that raised them. An event submitted from the portal, the API, the CLI, a webhook or a
legacy agent has no triggering instance, so it must name the workflow and
the schedule date in full — and, for JI., the job — or the event fails with Cannot default
schedule name: event has no triggering instance (or schedule date, or job name, for the part
left blank). A JI. name with every part blank raised from a workflow-level event fails
the same way, with event was not raised by a job — a workflow completion has no job for JI. to
mean.
The date part is read without reference to anyone's locale. These forms are accepted:
| Form | Example |
|---|---|
YYYY-MM-DD or YYYY/MM/DD | 2026-09-30, 2026/09/30 |
M/D/YYYY — month first, one or two digits, / only | 9/30/2026 |
D-Mon-YY or D-Mon-YYYY, with an English month name abbreviated to three letters or spelled in full | 30-Sep-26, 30-September-2026 |
YYYYMMDD | 20260930 |
A five-digit OLE automation serial between 32001 and 99998 | 46295 |
The D-Mon-YY forms are what make a rendered token work here: [[$SCHEDULE DATE]] renders
30-Sep-26 by default, and a name carrying one used to be refused as an invalid date. The date part
and an event's own schedule-date field (on the When Tokens Resolve tab) now read the same
forms, with two differences. The month-first numeric form takes / only in a name. A property
name is rendered with your date-format override, so a dash-separated 05-09-2026 from a dd-MM-yyyy
override is refused rather than read as 9 May. And a name's date part takes no time of day,
which the schedule-date field accepts and ignores — see
A date field accepts a date with a time of day (on the Events from Outside tab).
A two-digit year pivots at 2049: 26 is 2026, 50 is 1950. A month name in any other language is
refused rather than guessed. An impossible date such as 2026-02-30 is refused rather than rolled
forward, and a keyword such as CURRENT is not accepted in a name.
A dot that belongs to a name goes in double quotes. The quotes are removed after the split, so
JI.P..."STEP.1" names job STEP.1. This is how you reach a multi-instance job, whose instances
are named JOB.branch1: write JI.P..."JOB.branch1". A quote that is opened and never closed fails
the event.
What a write onto an instance refuses
Every refusal happens before anything is written, so a failed event changed nothing and stays safe to replay:
- A system property — a name the platform supplies, such as
$JOB NAMEor a date token — cannot be written. - An encrypted job property cannot be written — and neither can a name that differs from an encrypted one only in case, so the rule matches how every read path decides what to withhold.
SETorDELETEof a name the instance does not have fails rather than creating it;ADDis the operation that creates one.- A name that fails for any reason never falls back to the global property of the same name.
- An ambiguous sub-workflow target is refused. Nested children of a sub-workflow share its name
and date, so
SSI./SJI.picks among several candidates only when they are re-runs of one container, or builds under one top-level parent run. Anything else is refused rather than writing to whichever is newest.
A job instance's property is writable in any status, including while the job is running — Classic behaved the same way. The write is serialized against the operator actions and the dispatch sweep on that job, so if one of those is in flight the event reports another operation on job … is in progress, retries briefly, and then fails as a retryable failure rather than a permanent one.
Names match ignoring case, and the stored spelling is kept. Writing region onto an instance
that holds Region updates Region and leaves it spelled that way, so a [[JI.Region]] token
elsewhere keeps working.
A property value is never written to an audit trail, a history row or an error message. The event's state changes record the instance and the property name with the value redacted, exactly as they do for a global property event, and the job's history records that a property was written rather than what it was set to.
The Processes Job Editor saves a job instance's properties as a whole set. If a $PROPERTY event
changed one of them since the editor was opened, the save is refused rather than writing the older
set back over it. Re-open the job to pick up the current values and save again.
A machine-written property is also recorded as its own kind of history entry, not as an operator edit. Push Changes to Workflow does not carry an instance's properties at all, whoever changed them — see What a push carries.
Writing a machine property
A $PROPERTY:ADD, $PROPERTY:SET or $PROPERTY:DELETE whose name starts MI. writes one of an
agent's machine properties: the list its Machine
Properties dialog shows, and that [[MI.…]] tokens read.
The machine part names the agent. $PROPERTY:SET,MI.DISK_PCT.AIX53,93 writes DISK_PCT on
the agent AIX53, matched by its exact name, ignoring case and surrounding spaces. A name no agent
has fails the event with Machine not found: <name>, and a name several agents share fails
with Machine name <name> matches <n> machines; rename them so the name identifies one machine.
Left blank, it is the machine that raised the event. MI.DISK_PCT with nothing after it is:
- in an event a job fires, the agent the job ran on. If that agent cannot be identified, the
event fails with Cannot default machine name: the machine job
<job>ran on could not be identified; - in a legacy agent's event line, the machine that sent the line;
- anywhere else — an event a workflow fires, or one submitted from Self Service or the API — not available, and the event fails with Cannot default machine name: event has no triggering job or sending machine.
A dot in either part goes in double quotes. MI."app.home" names the property app.home, and
MI.X."MCP1." names an agent whose name ends in a period, as an MCP agent's does.
The three operations work as they do for an instance. ADD creates the property, or replaces
the value of one the agent already has. SET and DELETE need a property the agent has, and fail
with Property not found otherwise. A write of the value the property already holds changes
nothing. Names match ignoring case, and writing to an existing property keeps its stored spelling.
The same rules as the dialog apply, and every refusal happens before anything is written:
- names and values are trimmed;
- a name is 1 to 256 characters, with none of
'()\,=;|; - a system name is refused with This name is reserved for a system property.;
- a value is at most 4,000 characters;
- an agent holds at most 200 machine properties (An agent can have at most 200 machine properties.);
- a value copied from an encrypted property is refused, because a machine property is not encrypted.
It needs Agents Edit under All workspaces, for ADD, SET and DELETE alike, whichever agent
the name names. A job's or workflow's event is checked against the person who saves it, and a
legacy agent's line against its service account. A property name whose scope is filled in by a
token, such as [[OI.TARGET]].X, could write a machine property too, so saving one also needs
Agents Edit under All workspaces.
The event log records the agent and the property name. The value of an ADD or SET is redacted.
Properties on a schedule instance
A workflow's own properties are carried by its schedule instance, and are read with the SI
scope. A workflow with Allow Multi-Instance on defines a separate property set per named
instance, which is what makes one definition able to run per branch or per region — see
Schedule instances.
Two rules apply to those properties whether or not the workflow uses named instances:
InstanceNameis supplied by the platform. Every build stamps it with the instance's name, so[[SI.InstanceName]]always resolves; a workflow that defines no named instances getsDefault. It is written last, so a property of your own calledInstanceNamecannot shadow it.- An
Encryptedinstance property's value is not carried onto the run, so[[SI.…]]cannot read it. The run's property set is stored in the clear, so the value is omitted by name rather than copied — and it can't be supplied as a build-time override either, since the same name rule drops that too. The name match ignores case and trailing spaces, soApiKey,apikeyandApiKeycount as one property here. - Two names in one instance may not differ only in case or trailing spaces. The build would keep only the last value, so the save refuses the pair — see Property names that differ only in case.
Date and Time Tokens
Date and time tokens
Seven system names are the exception — they match on their prefix, so anything you write after the base name is read as a format, an offset, or both:
$SCHEDULE DATE · $SCHEDULE DATEMS · $JOB STARTTIME · $JOB ENDTIME · $DATE · $NOW · $TIME
$SCHEDULE DATE mm/dd/yy the schedule date, in that format
$JOB STARTTIME(+2hh) two hours after the job started
$SCHEDULE DATE mm/dd/yy(-1dd) yesterday's schedule date, in that format
Longer names win over shorter ones they extend, so $SCHEDULE DATEMS(-1dd) resolves as
$SCHEDULE DATEMS, not as $SCHEDULE DATE.
The format comes from a property, and the property's value is the format mask. The seven bare base names have built-in defaults:
| Token | Default format |
|---|---|
$SCHEDULE DATE | dd-mmm-yy |
$SCHEDULE DATEMS | ##### (the date as an integer) |
$JOB STARTTIME / $JOB ENDTIME | yyyy/MM/dd hh:mm:ss |
$DATE | Short Date |
$TIME | Long Time |
$NOW | General Date |
Write a suffixed name and the platform looks for a global property of that same name — offset
stripped — and uses its value as the format. So to use $SCHEDULE DATE mm/dd/yy, create a
global property named $SCHEDULE DATE mm/dd/yy whose value is the mask you want. If no such
property exists, the job fails with "No date format is defined for property …" rather than quietly
falling back to the default — because falling back would ignore the format you asked for.
One narrow exception, and only for a message: if you have overridden the format of one of the seven bare base names and the property store is briefly unreachable when a notification is sent, the date renders in that token's built-in default rather than leaving the token unresolved. A job parameter still defers instead — a machine instruction carrying a plausible but wrong date is worse than a job that waits.
Earlier builds couldn't do this at all: a property named after a date token plus a format either failed the job or rendered the mask literally. Naming one now resolves to the base token, with the suffix read as the format.
Two event fields are read by the platform as dates rather than shown to a person: the
schedule date a job or schedule event names, and the dates a $CALENDAR:ADD carries. A
token in either one always renders in its built-in format, whatever override you have defined.
This matters because your override and the platform's reader can disagree about which number is the
month. An override of dd/mm/yyyy renders 5 September as 05/09/2026; the field is read
month-first, so the event would have landed on 9 May — no error, just the wrong day. Rendering
these two fields in the built-in format is what removes that whole class of silent mistake.
The rule holds whichever way the event was raised — one a job or workflow fires, and one submitted from the portal, the API, the CLI, a webhook or a legacy agent. Those two are resolved on different paths, and for a while only the submitted path ignored the overrides.
A suffixed date token in one of those fields therefore has no format available, so the event is refused, naming the field — rather than running against a guessed day. Use the bare token there. Every other global still resolves normally, and every other field still honours your overrides.
A notification's OpCon Event action follows the same rule.
Offsets. A trailing (<signed number><units>) shifts the value. Units are matched exactly, in
any case:
| Units | Meaning |
|---|---|
yyyy, yy | Years |
qq, q | Quarters |
mm, m | Months |
wk, ww | Weeks |
dd, d | Days |
hh, h | Hours |
mi, n | Minutes |
ss, s | Seconds |
ms | Milliseconds |
t | Ticks |
eom | End of month |
| (none) | Days — (-1) is the same as (-1dd) |
Note mm is months and mi is minutes — they're matched by exact equality, never by first
letter, so there's no ambiguity, but they're easy to mix up when authoring.
wd — a working-day offset, as in $SCHEDULE DATE(-1wd) — is rejected. In a job parameter
the job fails with an error naming the offset; it never degrades to a calendar-day offset, because
silently shifting by the wrong number of days would be worse than failing. In a notification the
token renders unresolved and the message still goes out. Use a calendar to express
working days.