UC4 Script

UC4 Script — documented today as the Automation Engine (AE) scripting language of Broadcom’s Automic Automation — is a proprietary, imperative scripting language for enterprise workload automation. It is not written in standalone programs but embedded in the objects (jobs, workflows, events, schedules) that a central Automation Engine executes. Every statement begins with a colon, every variable begins with an ampersand, and any line that is neither a statement nor a comment is passed through verbatim as Job Control Language for the target system. That simple three-way split — script, comment, payload — has made the language a durable tool for describing batch work across wildly different platforms for more than two decades.

This page covers the scripting language itself; the broader product and engine history is covered in the companion UC4 entry.

History & Origins

UC4 Script did not begin life as a language project. Its home, the UC4 Automation Engine, descends from scheduling software built by SBB Software, founded in Austria in 1985. In 1996 SBB introduced one of the first heterogeneous job schedulers — a scheduler designed to coordinate batch work across different operating systems from a single point of control. A scheduler like that needs a way to express control logic that is independent of any one platform’s shell or JCL dialect, and the colon-prefixed scripting notation grew out of exactly that need.

The product line was rebranded UC4:global in 2002, gaining a multi-threaded server architecture, and in March 2004 the company renamed itself UC4 Software after its flagship product. From this period the scripting language became widely known simply as UC4 Script among the operations teams who wrote it. Ownership then changed hands repeatedly — The Carlyle Group took a majority stake in 2006, the company merged with scheduler vendor AppWorx in 2007, private equity group EQT acquired it in 2012, and on July 1, 2013 the company renamed itself Automic Software. CA Technologies acquired Automic in January 2017 (a deal announced in December 2016 at approximately 600 million euros, about 635 million USD), and Broadcom’s 2018 acquisition of CA brought the product to its current home, where it is sold as Automic Automation.

Remarkably, scripts written across those ownership eras still run: backward compatibility of customer script libraries has been a constant requirement, because large enterprises accumulate thousands of script-bearing objects that must survive every engine upgrade and corporate rebrand.

Design Philosophy

A Language Embedded in Objects

UC4 Script has no source files, compiler, or standalone interpreter. Script lives in the Process pages of Automation Engine objects — Job objects additionally have Pre-Process and Post-Process pages — and each Process page can hold up to 32,767 lines. A dedicated Script object type (SCRI) exists for logic that runs entirely inside the Automation Engine rather than on any target system. The engine interprets the script at activation time, and what the script generates is what actually runs on the agent.

Three Kinds of Lines

The language’s most distinctive design decision is lexical. In a Job object:

• Lines beginning with a colon (:) are script statements, interpreted by the Automation Engine.
• Lines beginning with an exclamation point (!) are comments and have no effect on processing.
• Lines beginning with neither are data lines — payload passed through to the target system as its native Job Control Language, whether that is z/OS JCL, a UNIX shell script, or Windows commands.

This lets one object interleave engine-side control logic with the platform-specific commands it emits, and it is why the same language can drive mainframes, UNIX boxes, Windows servers, databases, and SAP systems without itself knowing anything platform-specific.

Statements Do, Functions Return

Colon-prefixed elements split into two categories. Script statements (:SET, :PRINT, :IF, :INCLUDE, :PUT_ATT, :SEND_MSG, …) perform actions and return nothing; a statement must begin the line, and a single statement is limited to 1,024 characters. Script functions (SYS_DATE(), STR_CAT(), GET_VAR(), ADD(), …) return values and may not begin a line — they appear on the right-hand side of a statement, one function per line.

1
2
3

:PRINT "HELLO WORLD"
:SET &SUM# = ADD(2, 2)
:SEND_MSG "GREEN","EDP","Please start backup process."

Key Features

Variables

Script variables are prefixed with an ampersand, and ending the name with a hash character is the documented best practice so that similar names never collide during text substitution — &VALUE# and &VALUES# can safely coexist where &VALUE and &VALUES could not. Variable names are limited to 32 characters and are not case sensitive.

1
2
3

:SET &ACTIVITY# = "End"
:SET &TODAY#    = SYS_DATE()
:PRINT "&ACTIVITY# at &TODAY#"

Optional Typing with :DEFINE

A variable created directly with :SET has no specific data type and can hold strings and positive integers. For stricter handling, :DEFINE declares one of four data types:

1
2
3
4

:DEFINE &STRING#,   string
:DEFINE &SIGNED#,   signed
:DEFINE &UNSIGNED#, unsigned
:DEFINE &FLOAT#,    float

:DEFINE can also declare arrays by adding an element count, giving scripts indexed collections for holding lists of values read from variables or agent output.

Control Flow and Reuse

The language provides conditionals (:IF / :ELSE / :ENDIF), loop constructs for iterating over result sets (:PROCESS … :ENDPROCESS, typically fed by PREP_PROCESS* functions that return rows from files, variables, or agents), and :INCLUDE for pulling in shared script fragments stored in reusable Include objects — the language’s module system, in effect.

Talking to the Engine

Much of the language’s vocabulary is about the automation platform itself rather than general computation: reading and setting object attributes (GET_ATT, :PUT_ATT), activating other objects, sending operator messages (:SEND_MSG), writing to activation reports (:PRINT), and reading central VARA variable objects (GET_VAR). A UC4 script is less a program than a set of instructions to a running automation platform.

Generative AI Integration

The most recent addition is the ASK_AI script function, introduced with Automic Automation 24.4 in May 2025. It sends a prompt from a running script to a connected large language model — supported providers at release were OpenAI, Google Gemini, and Ollama — and returns the response for the script to process, enabling patterns like automatic summarization of failed-job reports or AI-enriched operator notifications.

Evolution

The language has always evolved as a passenger of the Automation Engine rather than on its own schedule. Each engine generation — the multi-threaded UC4:global server of 2002, the UC4-branded Automation Engine of the mid-2000s, the ONE Automation platform of the Automic years, and today’s Automic Automation with its Kubernetes Edition and SaaS offering — expanded what script objects could target: new agent types, managed file transfer, REST-based integrations, and most recently LLM services. The syntax itself has stayed remarkably stable, which is precisely the point: enterprises with decades of accumulated script objects upgrade engines, not languages.

Current Relevance

UC4 Script is alive and actively maintained. Broadcom continues to publish full documentation for the AE scripting language and ships new releases of Automic Automation; version 24.4 (May 2025) closed out the V24 feature line. The language remains invisible to most developers because it runs only inside a licensed Automation Engine — there is no open-source implementation, no package manager, and no Docker image to try it with. Its practitioners are workload automation engineers, and its habitat is the operations side of banks, insurers, manufacturers, universities, and telecoms.

That closed world has a measurable footprint: competing scheduler vendors market dedicated conversion tooling for migrating Automic script libraries, which is as clear a signal as any of how much production logic exists in this language.

Why It Matters

UC4 Script exemplifies the embedded automation DSL — a category of languages that coordinate enormous amounts of real-world computing while remaining absent from every popularity index.

1. It expresses the batch layer. The overnight processing that reconciles accounts, loads warehouses, and closes books has to be described in something; in thousands of enterprises, that something is UC4 Script.
2. Its lexical design is quietly elegant. The colon/exclamation/data-line split lets one small language generate and control any platform’s native job language without absorbing any platform’s syntax — a clean solution to heterogeneity that predates modern “orchestration” tooling by decades.
3. It demonstrates survivorship through lock-in. With no standard and no life outside its engine, the language has nonetheless outlived repeated changes of corporate ownership, because the automation written in it is too valuable to rewrite.

For code archaeologists, UC4 Script is a reminder that some of the most consequential languages are the ones almost nobody outside a data center has ever read.