Appearance
Variables
Ordyn has two variable layers:
- persistent variables, which belong to the shared variable catalog and resolve through the scopes that apply to the current operation
- runtime job variables, which exist only for one target during one job run
Persistent variables use vars.*. Runtime job variables use job.vars.*. The same templating system can read both.
Variable definitions
Create custom definitions for reusable values, choosing a stable key, value type, and optional default. System definitions are supplied by Ordyn; super administrators can edit their defaults. Use scoped overrides for values that differ across devices or environments.
Mark credentials as secret. Use Retrievable only when administrators need to reveal the stored value, for example for device recovery. Reveals are audited.
String variables support multiline values, including certificates. When a script needs exact original bytes, encode the value and decode it in the script; browser text entry normalizes line endings.
Scope and inheritance
Every persistent variable starts with its definition default. An applicable override replaces the value from every broader scope. The exact scopes depend on where Ordyn is resolving the variable.
| Source | Where it applies |
|---|---|
| Definition default | Every context in which the definition is available. |
| Tenant | Endpoints in that tenant. |
| Endpoint folder | Endpoints in that folder and its descendant folders. Parent folders resolve before child folders. |
| Group | Endpoints that belong to the group. Group priority decides between matching groups. |
| Endpoint | That endpoint. |
| Product | The software product and endpoint tasks using it |
| Package | The package and endpoint tasks using it. A package inherits from its product. |
| Infrastructure job folder | Infrastructure jobs in that folder and its descendant folders. Parent folders resolve before child folders. |
| Job | Runs of that saved job. |
| Submitted run value | The selected target or targets in the run being started. Only prompt-enabled job variables accept submitted values. |
Endpoint folders participate only in endpoint inheritance, and infrastructure job folders participate only in infrastructure-job inheritance. Endpoint-job folders, group folders, package folders, and variable-definition folders are organizational and don't override variables.
Endpoint job resolution
An endpoint task resolves the complete applicable chain in this order:
text
Definition default
→ endpoint tenant
→ endpoint folder ancestry
→ winning endpoint group
→ endpoint
→ task product
→ task package
→ job
→ submitted run valueAn ordinary task skips the product and package layers and proceeds from the endpoint to the job and submitted value. A product task adds its product. A package task adds the package's product and then the package. This means a package value can override an endpoint value for that package task without affecting ordinary tasks in the same job.
The endpoint, product, and package layers remain live while an endpoint run is active. The job value and submitted run value are frozen when the run is created.
Infrastructure job resolution
Infrastructure jobs resolve custom definitions in this order:
text
Definition default
→ infrastructure job folder ancestry
→ job
→ submitted run valueThe complete result is frozen when the run is created. Later changes to a definition default, folder override, or job override do not alter that run. See Job Variables for prompts and run behavior.
Product and package resolution
Outside an endpoint job, a product resolves the definition default and its product override. A package resolves the definition default, its product override, and its package override.
Matching groups
When an endpoint belongs to several groups with an override for the same definition, the override with the highest priority wins. If two or more matching groups share the highest priority, the group layer is ambiguous. The UI lists the conflicting groups, and Ordyn does not expose that variable to the task. Add a more specific endpoint, product, package, job, or submitted run value, or assign distinct group priorities, to resolve the conflict.
Null values and removal
An explicit null at a more specific scope masks values from broader scopes and is exposed to the job as an unresolved value. Removing the override removes the mask and restores normal inheritance.
Inspect effective values
Review the effective value and its source on the relevant scope before running work. A job's displayed default does not include every target-specific value; see Job Variables.
Use secret variable definitions for passwords and secret settings. Leaving a secret input blank while editing preserves it; clear it explicitly to remove the value.
To branch on customization rather than the value, use has_endpoint_variable_override as described under Advanced expressions.
Built-in credential variables
Ordyn provides these retrievable secret system variables for device credentials:
hardware.firmware.passwordhardware.intel_amt.admin_passwordhardware.intel_amt.mebx_passwordwindows.local_admin_password
Their values are encrypted and redacted by default. Authorized administrators can reveal a value from the Variables page; every reveal is audited. Configure a global default only when devices share a credential and use overrides where credentials differ.
windows.local_admin_username is a non-secret system variable. Its default is OrdynAdmin; a super administrator can edit that default from the Variables page.
Firmware password
hardware.firmware.password is a built-in secret variable that authorizes firmware-setting remediation on password-protected devices.
Configure it with the device's existing Dell Admin or BIOS setup password. The value is resolved through the normal endpoint variable precedence, so you can configure a shared secret at a broader scope and add endpoint overrides for devices with different passwords.
Firmware / BIOS Policy remediation uses the password when it finds drift and the device reports that an Admin BIOS password is set. Audit-only runs do not use it. If the device has no Admin BIOS password, a configured value is ignored.
A missing or incorrect value causes protected remediation to report an error. Editing this variable changes the stored credential. Use Set/change BIOS admin password to change the device's password. A successful job stores the applied password as an endpoint override and shows it in plain text in job output.
Value history
Select a variable and choose Revisions from its context menu to browse retained values. In an endpoint or other scope's variable list, revisions show values recorded for that scope.
To find a deleted override, open the scope's Variables tab, select View → All variables, and choose Revisions from the variable's context menu. If several override histories are available, choose the history you need using its last change time and actor. Open a revision from before deletion to read the recorded value. Viewing a revision does not restore the override.
Use Variables → Actions → Revision archive to find retained values when the variable or endpoint itself has been deleted. Search by variable key, label, or recorded scope name, such as an endpoint name.
To apply a retained value again, choose Restore on a revision from before deletion. This recreates the override and records a new revision. See Restore a revision for access and dependency requirements.
Revisions include values recorded at creation, replacement, clearing, and deletion, together with the original scope, time, and actor. These values remain available after the endpoint or variable is deleted. Retention has no expiry.
Firmware password job runs record the previous credential and the proposed password in their output and downloaded logs, including attempts with an uncertain outcome. These records are accessible while the job run is retained. A successful password change also saves the applied password as an endpoint variable override, creating a variable revision.
Secret values in revisions are masked. Use Reveal value when your assigned role supports viewing credentials in that scope. A version must have been retrievable when it was recorded. Changing the variable's retrievability does not unlock older versions. Reveals are audited. Job output displays firmware passwords directly without a reveal action.
Runtime job variables
Use Set job variable to store job.vars.<name> for later steps on the same target. Values are not shared with other targets or new runs. Writing the same name replaces its value.
Generate password creates a secret runtime value. A completed generation step keeps its value when the run resumes; another executed loop iteration generates a new one.
Runtime secrets remain with retained run data. See Infrastructure run retention. They do not become entries in persistent variable history.
Templating
Fields that support templating accept {{ ... }} placeholders.
Use template fields when you want Ordyn to resolve values during execution inside otherwise literal text. If the whole field is one template expression, Ordyn preserves the resolved scalar type. If you mix literal text and template expressions, Ordyn turns the result into text.
Common template sources include:
vars.*for persistent variablesjob.vars.*for runtime job variablessteps["step-id"].result.*for earlier task resultsendpoint.*for endpoint contexttrigger.*for the event or action that started the job runjob.run.*for current run metadatajob.git.*for the infrastructure job's Git sourcejob.workspacefor the absolute shared workspace path in supported endpoint and infrastructure job fieldscollector["collector-id"].fieldfor stored collector valuesloop.*inside loop bodies
Common endpoint context fields include endpoint.id, endpoint.kind, endpoint.hostname, endpoint.fqdn, endpoint.tenant_id, and endpoint.primary_ip_address. The primary address comes from the endpoint's primary network interface and is null when no primary address is available.
Missing template paths fail the task instead of resolving as empty text.
For endpoint jobs, {{ job.workspace }} resolves to the workspace shared by all tasks for that endpoint target. Endpoint scripts and package commands use this directory as their default working directory. Each endpoint target has a separate workspace, and Ordyn removes it after the target finishes.
For infrastructure jobs, {{ job.workspace }} resolves to the reserved Runner's host workspace path. In Docker execution it resolves to the job's configured container workspace path. Use it in inline Runner script content, executable paths and arguments, string parameters, environment values, and rendered staged-file content. Runner working directories, file-placement destinations, Git checkout destinations, and artifact paths remain workspace-relative and do not accept this reference.
Saved Runner script content is executed verbatim. Use ORDYN_WORKSPACE in the script or pass the workspace through a string parameter.
Commands receive the resolved secret values they need. Do not rely on output redaction to protect transformed values or files; follow script secret guidance.
Endpoint infrastructure roles
Endpoint jobs can read the infrastructure roles configured in Edit endpoint:
| Variable | Type | Meaning |
|---|---|---|
endpoint.infrastructure_roles.ordyn_server_host | boolean | Whether the endpoint is marked as an Ordyn server host. |
endpoint.infrastructure_roles.ordyn_edge_host | boolean | Whether the endpoint is marked as an Ordyn edge host. |
endpoint.infrastructure_roles.ordyn_hypervisor_host | boolean | Whether the endpoint is marked as an Ordyn hypervisor host. |
endpoint.infrastructure_roles.edge_service_id | string or null | Assigned Edge service ID for an Ordyn edge host, or null when no Edge service applies. |
These fields are available as Endpoint field references in the guided If branch editor.
The equivalent raw condition is:
text
endpoint.infrastructure_roles.ordyn_server_host == trueRole variables describe the job target endpoint even when another supported task uses a fixed execution endpoint.
Expressions
Some fields use raw expressions instead of {{ ... }} placeholders.
That is the case for:
- condition editors
Set job variableSet variable override
In those fields, write the expression directly, for example:
endpoint.primary_uservars.site_codejob.vars.selected_sitejob.run.total_stepssteps["check"].result.outcomevars.registry.token
Secret variable expressions in Set job variable resolve the real value and store the result as an encrypted runtime secret. Set variable override rejects secret expressions for non-secret destinations. Setting a persistent secret override requires a source secret variable from the catalog; generated runtime passwords are not catalog variables.
To collect diagnostics only after the main work fails, add an If task in Cleanup with job.run.main_status == "failed". The main result can be succeeded, failed, aborted, or timed_out; it is not set while Tasks are running.
job.run.phase identifies the current section as main or cleanup. Cleanup can also use earlier step results and job variables.
Advanced expressions
Advanced expressions can reference:
- earlier task results through
steps["<step-id>"] - persistent inherited variables through
vars.<name> - built-in endpoint context through
endpoint.<field> - job run trigger details through
trigger.<field> - explicit runtime job variables through
job.vars.<name> - current run metadata through
job.run.<field>
The same authored reference model is used by jobs, package workflows, and OS image workflows so branching logic behaves consistently across editors.
Examples:
steps["task-id"].result.outcome == "terminated"steps["task-id"].result.reboot_required == truesteps["task-id"].result.is_installed == falsesteps["task-id"].result.found == truesteps["task-id"].result.updated_key_count == 1vars.site_code == "BER" || vars.site_code == "MUC"endpoint.system.battery_charge_percent >= 50trigger.type == "self_service"trigger.self_service.windows_account == "ACME\\alex"job.vars.install_state == "ready"job.run.total_steps > 4steps["task-id"].status == "succeeded" && vars.process_state != "failed"contains(vars.site_code, "BER")!contains(vars.site_code, "TEST")is_empty(vars.maintenance_window)!is_empty(job.vars.detected_version)has_endpoint_variable_override("vars.site_code", "direct_endpoint") == truehas_endpoint_variable_override("vars.site_code", "effective") == false
Use a Set job variable step when you want to store a runtime value for later job steps or branches. That step writes into job.vars.*.
Supported operators:
==!=>>=<<=&&||- parentheses for grouping
String values additionally support:
contains(value, needle)!contains(value, needle)is_empty(value)!is_empty(value)
Array values support exact membership checks:
contains(vars.allowed_paths, "/opt/ordyn-api")!contains(vars.ignored_paths, loop.vars.compose_project.working_dir)
In the visual condition editor these appear as contains, does not contain, is empty, and is not empty for string sources. Empty-string checks should use is empty / is not empty; do not rely on comparing against "" in the guided editor.
Variable override checks use:
text
has_endpoint_variable_override("vars.<variable-key>", "direct_endpoint")
has_endpoint_variable_override("vars.<variable-key>", "effective")The first argument must be a persistent variable reference under vars.*. The second argument must be either direct_endpoint or effective.
Runtime references
Use task results for values produced earlier in the same run. Use a collector reference for the endpoint's latest stored value:
text
collector["collector-id"].battery_charge_percent >= 80Stored collector values can be older than the current job. Use the result of Run collector when the branch needs that collection's output.
Git source variables
Infrastructure jobs with a Git source can use these values in steps after checkout:
| Variable | Meaning |
|---|---|
job.git.ref | Full checked-out ref, such as refs/pull/42/head. |
job.git.logical_branch | Logical branch name from the repository specification. |
job.git.commit | Full commit SHA actually checked out. |
job.git.repository_name | Name of the selected repository entry. |
job.git.repository_url | Repository URL. |
For example, pass {{ job.git.commit }} to a build script to include the source revision in its output. These checkout values are unavailable when resolving the job's default branch.
Trigger variables
Every job run target receives trigger details under trigger.*.
Common fields:
| Variable | Meaning |
|---|---|
trigger.type | The run origin, such as manual, time, self_service, webhook_received, git_changed, snmp_trap_received, endpoint_connected, post_enrollment, system_boot, user_logon, user_logoff, job_completed, windows_update_approved, or system_shutdown_requested. |
trigger.source | The source category, such as manual, schedule, self_service, webhook, snmp, or automation. |
trigger.target_endpoint_id | Endpoint target for this job run target. Infrastructure runs do not provide an endpoint target. |
Git changes runs include the detected source revision:
| Variable | Meaning |
|---|---|
trigger.git.repository_id | Shared repository entry ID. |
trigger.git.ref | Full Git ref that changed. |
trigger.git.commit | Detected commit pinned for this build. |
Manual runs can include:
| Variable | Meaning |
|---|---|
trigger.mode | Manual run mode, such as selected endpoints, assigned endpoints, or scope. |
trigger.user.id | User ID that started the run. |
trigger.user.name | User display name. |
trigger.user.email | User email address. |
Time-based runs can include:
| Variable | Meaning |
|---|---|
trigger.schedule.id | Schedule ID. |
trigger.schedule.name | Schedule name. |
trigger.schedule.scheduled_for_at | Scheduled run time. |
trigger.schedule.deferred | Whether the run waited for an offline endpoint to reconnect. |
Windows update approval runs can include:
| Variable | Meaning |
|---|---|
trigger.windows_update.approval_count | Number of approval events combined into this run. |
trigger.windows_update.ring_ids | IDs of enabled Windows update rings involved in the combined event. |
trigger.windows_update.approval_sources | Approval sources included in the event, such as manual or automatic. |
trigger.windows_update.reasons | Reasons the approvals became active, such as approval or ring_enabled. |
trigger.windows_update.first_event_at | Time of the first combined approval event. |
trigger.windows_update.last_event_at | Time of the most recent combined approval event. |
Self-service runs can include:
| Variable | Meaning |
|---|---|
trigger.self_service.windows_account | Windows account that requested the run. |
trigger.self_service.source_session_id | Windows session ID that launched the portal request. Use it to target self-service user messages and session-scoped process termination. |
trigger.self_service.source_endpoint_id | Endpoint where the portal request came from. |
trigger.self_service.source_endpoint_hostname | Hostname where the portal request came from. |
trigger.self_service.target_endpoint_id | Endpoint selected for the job. |
trigger.self_service.target_endpoint_hostname | Hostname selected for the job. |
trigger.self_service.target_endpoint_ids | Endpoint IDs included in the self-service run. Multi-device self-service runs include every eligible assigned endpoint. |
trigger.self_service.target_endpoint_count | Number of endpoints included in the self-service run. |
trigger.self_service.authorization_basis | Policy basis that allowed the request. |
Webhook runs can include:
| Variable | Meaning |
|---|---|
trigger.webhook.event_id | Stored webhook event ID. |
trigger.webhook.webhook_id | Webhook definition ID. |
trigger.webhook.service_client_id | Webhook service client ID. |
trigger.webhook.endpoint_id | Endpoint targeted by an endpoint-scoped webhook. Infrastructure-scoped webhooks leave this value empty. |
trigger.webhook.method | HTTP method. |
trigger.webhook.source_ip | Resolved caller source IP. |
trigger.webhook.content_type | Request content type, when provided. |
trigger.webhook.headers | Normalized request headers. |
trigger.webhook.query | Query parameters. |
trigger.webhook.body | Parsed request body. |
trigger.webhook.raw_body | Raw request body text, when present. |
trigger.webhook.payload | Full normalized request payload. |
SNMP trap runs can include:
When one trap fans out to multiple endpoints, every resulting run receives the same stored trap event and normalized payload.
| Variable | Meaning |
|---|---|
trigger.snmp.event_id | Stored trap event ID. |
trigger.snmp.service_client_id | SNMP service client ID. |
trigger.snmp.source_address | Trap source address. |
trigger.snmp.source_port | Trap source port. |
trigger.snmp.version | SNMP version. |
trigger.snmp.auth_identity | Community or SNMPv3 identity. |
trigger.snmp.trap_oid | Trap OID. |
trigger.snmp.enterprise_oid | Enterprise OID, when present. |
trigger.snmp.uptime_ticks | Device uptime ticks from the trap. |
trigger.snmp.varbinds | Trap varbind list. |
trigger.snmp.payload | Full normalized trap payload. |
Windows user logon and logoff runs can include:
| Variable | Meaning |
|---|---|
trigger.windows_session.event_id | Unique ID of the accepted logon or logoff event. |
trigger.windows_session.occurred_at | Time reported by the endpoint agent. |
trigger.windows_session.principal | Windows account name, when Windows provides it. This can be empty for logon or logoff events. |
trigger.windows_session.session_id | Windows session ID. |
trigger.windows_session.is_console | Whether this is the local console session. |
trigger.windows_session.is_remote_desktop | Whether this is a Remote Desktop session. |
System boot runs can include:
| Variable | Meaning |
|---|---|
trigger.system_boot.event_id | Unique ID of the detected system boot event. |
trigger.system_boot.boot_id | Boot identity reported by the endpoint. |
trigger.system_boot.previous_boot_id | Boot identity reported before this boot. |
trigger.system_boot.booted_at | Estimated operating-system boot time, based on the report time and uptime when available. |
trigger.system_boot.observed_at | Time Ordyn detected the changed boot identity. |
trigger.system_boot.uptime_seconds | Endpoint uptime reported when the boot was detected. |
Job-completed and shutdown automations can include:
| Variable | Meaning |
|---|---|
trigger.source_job_run_id | Source job run ID, when another job triggered the run. |
trigger.source_job_run_target_id | Source job run target ID, when available. |
trigger.shutdown_request_id | Shutdown request ID for shutdown-triggered runs. |
Branching example
process.terminate exposes a normalized runtime result:
result.outcometerminatednot_runningfailed
result.matched_process_countresult.terminated_process_count
That makes the common "terminate if running, otherwise continue" pattern much less brittle than matching free-form stderr text.
One example flow:
- terminate process
AcmeApp.exe - add a
Set job variabletask that stores the task'sOutcomeasjob.vars.process_state - add an
iftask that checks whetherjob.vars.process_stateequalsnot_runningorterminated - run uninstall only in the selected
thenbranch
Common patterns
- Use a persistent variable for environment, tenant, or folder defaults.
- Use
Set variable overridewhen job logic should set, null, or remove a persistent override for a tenant, endpoint folder, group, or endpoint. - Use
Set job variablewhen a later step in the same target needs the computed value again. - Use templated fields for commands, file content, scripts, and other text that should mix literal text with resolved values.