With Automic Automation V26, the Automic V26 Python integration is no longer a SaaS-only capability — it is available to everyone running the Automation Engine, on-premises customers included. Python now runs natively inside Automic through dedicated Job objects, so engineers can build and orchestrate Python logic without the fragile shell-to-Python wrapper scripts that used to glue the two worlds together.
This article is part of our Automic V26 enablement series at Tricise. It looks at one capability in depth and is written to be read alongside the rest of the series — it is not a standalone overview. For the full feature-by-feature picture, start with our companion piece, Automic Automation V26: The Top 7 Features.
What the Automic V26 Python integration changes
The native Python Job types first shipped in version 24.5, but only for SaaS customers. The Automic V26 Python integration is the moment they become generally available to all users of the Automation Engine, including self-hosted environments. The goal is straightforward: make automation solutions faster to build, more flexible, and approachable for a wider group of people — not only AE scripting specialists.
Because Python and the Automation Engine scripting language can be combined in the same Job, you can extend existing automation logic with Python instead of rebuilding it. The two languages work side by side rather than in separate silos.
Three new Python Job objects
The integration adds three new Job objects: the Generic Python Job, the Unix Python Job, and the Windows Python Job. Their structure deliberately mirrors the classic Job objects you already know in Automic, which keeps the learning curve short. Like other jobs, they can run on their own or be placed inside a Job Group, a Workflow, or a Schedule.
Inside a Python Job object
The new objects add a dedicated Python page where the Start Parameter section holds everything the interpreter needs:
- Python Interpreter — which interpreter to use (leave it empty to fall back to the system default, or enter a full path).
- Options — start-up parameters passed to the interpreter.
- Working Directory — where the Python execution should take place.
- Requirements — the list of Python packages the job needs to run.
The actual Python code goes on the Process page, exactly where you would expect to place job logic. You can write pure Python, or mix it with Automation Engine script, and you can use script variables inside the Python fields.
The PIP report and dependency handling
When a Python Job runs, the agent reads the package list from the Requirements field and calls the Python package manager (PIP) to install anything that is not already present. Automic then generates a new, dedicated report — the PIP report — that records the outcome of those installations. If a required package cannot be installed, the job is aborted and does not start, so a missing dependency fails fast and visibly rather than halfway through your logic.
In the enablement session we showed a small example that read a system’s current iptables rules with Python and printed them straight into the job report — a reminder that anything Python can produce becomes part of Automic’s auditable output.
Passing variables between Python and Automic
The integration is genuinely two-way. To send results from Python back into Automic, you use the automic_register_variable statement — the Python equivalent of :REGISTER_VARIABLE. In the session we read the host name and the current working directory in Python and registered both as Automic script variables, which then stood ready for post-processing like any other AE variable.
The other direction works just as cleanly. Automic exposes its variables to Python through the _automic_variables dictionary and the _automic_job object, so a value set in AE script — for example a city stored in &city# — can be read and printed directly in Python. There is no extra glue code: existing automation logic can be extended with Python in either direction.
That covers what the new Python Jobs are and how they exchange data with Automic. It is easier to see than to read about, so the tutorial below walks through building and running a Python Job end to end.
With the walkthrough in mind, here are the use cases worth trying first — starting with one that used to be surprisingly painful.
A practical example: processing Excel files
One of the more compelling use cases shown in the session was Excel processing. Reading spreadsheets used to mean reaching for bespoke Java programs or external tools.
With native Python, an .xlsx file is read directly, and the relevant rows and columns are handed over to Automic script arrays for further processing inside the workflow — no middleware and no brittle interfaces in between. The reverse is supported too: data produced in Python can be written back into Automic script arrays.
(Array exchange is highlighted as a V26 capability in the enablement material; confirm the exact array syntax against the official V26 documentation for your environment.)
Getting started: prerequisites for a Python Job
Setting up a Python Job follows the same pattern as any other executable object. On the Attributes page you select the agent and the Login object that carries the credentials to access it — a Windows agent for a Windows Python Job, a Unix agent for a Unix Python Job.
On any Process page you write the script the job should execute, in pure Python or in a combination of Python and Automation Engine script. From there you fill in the interpreter, options, working directory, and package requirements on the Python page, and the job is ready to schedule.
One practical detail worth noting for Windows: if your scripts contain Unicode characters, you need to pass the -X utf8 option to the interpreter, because the Windows default does not interpret UTF-8 correctly without it.
Monitoring and troubleshooting Python Jobs
Once a Python Job is activated it behaves like any other task in the Process Monitoring perspective: you can see its status in the task list and open its monitor, where a read-only Python page shows the settings as defined in the job, including the resolved values of any variables you used.
Alongside the standard reports, the integration benefits from Automic’s Gen AI tooling. The Automation AI Assistant can analyze the last execution of a job — it crawls the available reports and logs, summarizes what happened, and suggests how to resolve existing or potential issues, with a direct link back to the execution and its report.
For Python work, where a stack trace or a failed dependency is often the root cause, that turns troubleshooting into a much shorter loop.
Why this matters for your automation
For teams that run DataOps pipelines combining Automic orchestration with Python processing, this is a real productivity gain. It brings open-source and Python workloads back under centralized Automic governance, removes a whole class of fragile wrapper scripts, and lowers the barrier for data and platform engineers who already think in Python.
That fits a broader V26 theme: Broadcom positions the release around bringing disjointed open-source orchestrators back under enterprise governance without slowing developer velocity, and native Python is one of the most tangible expressions of that idea. The same code that a data engineer would otherwise run in an isolated scheduler now sits inside auditable, policy-bounded Automic objects.
If you operate or manage an Automic estate, our Application Managed Services team can help you put capabilities like these to work in production.
This was a short, focused look at the Automic V26 Python integration. The official details are documented in Broadcom’s Windows Python Jobs documentation and the Python Scripting reference, which cover the interpreter settings, the variable dictionary, and the registration statements in full.
Go deeper: live Automic V26 upgrade webinars
If you are weighing the move to V26, Tricise runs a free 45-minute upgrade session with Automic specialist Jens Pilz — the upgrade pitfalls, the top five changes to existing functionality, and the new AI features worth your time. It runs twice, once in each language:
- Automic V26 Upgrade webinar — German edition (26 June 2026, 10:00 CEST)
- Automic V26 Upgrade webinar — English edition (22 July 2026, 14:00 CEST)
Frequently asked questions
Which Python Job types does Automic V26 add?
Three: the Generic Python Job, the Unix Python Job, and the Windows Python Job. Each mirrors the structure of the classic Automic Job objects and can run on its own or inside a Job Group, Workflow, or Schedule.
Do I need Automic SaaS to use the Automic V26 Python integration?
No. The Python Job types originally shipped in version 24.5 for SaaS customers only. With V26 they are generally available to all Automation Engine users, including on-premises environments.
What happens if a required Python package fails to install?
The agent calls PIP to install the packages listed in the Requirements field. If any of them cannot be installed, the job is aborted and does not start. The dedicated PIP report records the result of the installation so you can troubleshoot the dependency quickly.
Can Python and Automic script variables exchange values in both directions?
Yes. Python values are registered back into Automic with automic_register_variable (the equivalent of :REGISTER_VARIABLE), and Automic variables are exposed to Python through the _automic_variables dictionary and the _automic_job object.
Where do I configure the interpreter and the required packages?
On the Python page of the job, in the Start Parameter section: the Python Interpreter, its Options, the Working Directory, and the Requirements list of packages. The Python code itself goes on the Process page.
Put Automic V26 to work with Tricise
Want to turn the new Python capabilities into running automation? Book a free consultation with the Tricise Automic Automation team — as Broadcom’s largest strategic partner in Europe, we help you plan the V26 upgrade and build the use cases that matter for your environment. And if you are working through the rest of the release, keep going with our Automic V26 enablement series.
