<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Enterprise on Step Documentation</title>
    <link>https://step.dev/knowledgebase/30/categories/enterprise/</link>
    <description>Recent content in Enterprise on Step Documentation</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Wed, 03 Jun 2026 11:00:00 +0200</lastBuildDate><atom:link href="https://step.dev/knowledgebase/30/categories/enterprise/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Step AI Ecosystem</title>
      <link>https://step.dev/knowledgebase/30/ai/ecosystem/</link>
      <pubDate>Wed, 03 Jun 2026 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/ai/ecosystem/</guid>
      <description>In short The Step AI Ecosystem extends the Software Automation as Code approach with autonomous software testing capabilities powered by large language models (LLMs) and AI agents. The Step platform unifies AI-driven functional testing, load testing, and monitoring while integrating seamlessly into existing CI/CD and DevOps workflows.
The Step AI Ecosystem is built on three layers:
Step MCP Server for connecting AI assistants and coding agents to Step Reusable Testing Skills for packaging Step testing expertise into reusable workflows Step Testing Agent for generating, executing, self-healing and validating tests on Step Together, these capabilities enable agentic testing workflows that accelerate test creation, reduce maintenance effort, and improve automation reliability.</description>
    </item>
    
    <item>
      <title>Automation as Code</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-as-code/</link>
      <pubDate>Wed, 21 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-as-code/</guid>
      <description>Step&amp;rsquo;s unique Software automation as Code approach (short Automation as code) enables developers to define software automation workflows for the whole DevOps lifecycle as code alongside the product code.
This concept is the key enabler for shift-left in not just testing but for all disciplines relating to software automation. This ranges from large scale E2E acceptance tests to load and performance tests, synthetic monitoring, RPA, and much more.
This pages presents the use-cases enabled by the Automation as Code approach.</description>
    </item>
    
    <item>
      <title>JDBC (SQL)</title>
      <link>https://step.dev/knowledgebase/30/plugins/analytics-integrations/jdbc/</link>
      <pubDate>Wed, 17 Mar 2021 14:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/analytics-integrations/jdbc/</guid>
      <description>The JDBC plugin writes Step measurements to a SQL-based database such as PostgreSQL or MySQL. This allows you to query and visualize Step execution data using any SQL-compatible tool.
The JDBC plugin exports measurements only — it does not export keyword-emitted metrics (counters, gauges, histograms). For full metrics export, use the Prometheus or Metrics Logger integration. The plugin has been tested with PostgreSQL 12 and MySQL 8.
Data model Since keywords in Step can carry arbitrary custom attributes, each measurement contains a set of fixed fields and an open-ended set of custom fields:</description>
    </item>
    
    <item>
      <title>.NET agent</title>
      <link>https://step.dev/knowledgebase/30/plugins/dotnetagent/</link>
      <pubDate>Wed, 10 Apr 2019 14:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/dotnetagent/</guid>
      <description>.NET Plugin Installation Installation Follow this link to install the .NET Step Agent : .NET Agent installation
Keyword Project .NET Solution To create new keywords for the .NET agent with Visual Studio Solution, you must first create a new Console Application project in Visual Studio:
You will then be able to choose between the latest .NET 5.0 framework or the legacy 4.x version (please note that only the latest 4.x version of the framework is tested before the release).</description>
    </item>
    
    <item>
      <title>Notifications</title>
      <link>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/notifications/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/notifications/</guid>
      <description>Step includes a flexible mechanism for sending notifications using various methods. Such notifications are meant to work in tandem with the Alerting Rules, allowing to define exactly which events and conditions will result in which notification being sent, with what data.
In order to use Preset-based notifications, Step administrators must define at least one System Notification Preset. Introduction and Example Step currently supports two kinds of notifications: good old E-Mails, and Webhook calls.</description>
    </item>
    
    <item>
      <title>Prometheus</title>
      <link>https://step.dev/knowledgebase/30/plugins/analytics-integrations/prometheus/</link>
      <pubDate>Wed, 17 Mar 2021 14:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/analytics-integrations/prometheus/</guid>
      <description>Prometheus is a popular open-source monitoring and alerting system. The Step Prometheus plugin exposes measurements and metrics at a scrape endpoint that Prometheus polls at regular intervals.
In addition to Step execution data, the plugin also exposes JVM and Jetty metrics for internal controller monitoring. Note that while not directly related to this plugin, other Step components such as the Grid proxy and Java agents can also expose these metrics to Prometheus via their own configuration.</description>
    </item>
    
    <item>
      <title>Automation Packages</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-packages-overview/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-packages-overview/</guid>
      <description>The concept of Automation Packages provides a standard for defining software automation workflows for the whole DevOps lifecycle in a unified way. Following the Automation as Code paradigm, it allows developers to define software automation logic as code alongside the actual application&amp;rsquo;s code, and provide all the means to execute and deploy this logic at the different stages of the DevOps lifecyle.
Technically the Automation Package standard consist of:
The Automation Package syntax that defines a standard to describe a wide range of automation workflows in a unified way The Automation Package format that defines a standard for packaging entities (like Keywords, Plans, Resources, data, etc) The Automation Package CLI that allows to build, execute and deploy Automation Packages Automation Packages in a nutshell In a nutshell an Automation Package is a self-contained set of Plans and their related entities (Keywords, Parameters, Resources&amp;hellip;) that can be executed on a Step controller or deployed to it for later use.</description>
    </item>
    
    <item>
      <title>Alerting rules</title>
      <link>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/alerting/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/alerting/</guid>
      <description>Step includes a rule-based mechanism that allows users to define flexible reactions to various events.
In a nutshell, rules allow you to define when to react to specific events (conditions), and how (actions).
The following illustration presents the process in a simplified, informal form:
Events Events are automatically generated by the Step environment and fed into the alerting rules evaluation component. Events contain further details about what happened, in the form of Bindings.</description>
    </item>
    
    <item>
      <title>Jira Xray</title>
      <link>https://step.dev/knowledgebase/30/plugins/jira-xray/</link>
      <pubDate>Tue, 18 Oct 2022 10:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/jira-xray/</guid>
      <description>Starting with version 20, Step Enterprise Edition provides support for integration with the popular Xray Test Management plugin for Jira. Both the Cloud and the Server edition of Xray are supported.
Installation and Configuration In order for Step to integrate with Jira and Xray, the systems will need to communicate with each other. The requirements differ between the editions of Xray, so please follow the steps for the Xray edition you want to integrate with.</description>
    </item>
    
    <item>
      <title>Metrics Logger</title>
      <link>https://step.dev/knowledgebase/30/plugins/analytics-integrations/metrics-logger/</link>
      <pubDate>Wed, 17 Mar 2021 14:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/analytics-integrations/metrics-logger/</guid>
      <description>The Metrics Logger plugin writes Step measurements and metrics to structured log files using Logback. The log format is compatible with Splunk and other log aggregation tools.
Enabling the plugin The plugin is disabled by default and must be explicitly enabled in step.properties:
plugins.MetricsLoggerControllerPlugin.enabled=true Log configuration Log output is controlled by the CONTROLLER_DIR/bin/logback.xml file. The default configuration writes to a rolling file:
&amp;lt;appender name=&amp;#34;MEASUREMENTS&amp;#34; class=&amp;#34;ch.qos.logback.core.rolling.RollingFileAppender&amp;#34;&amp;gt; &amp;lt;file&amp;gt;../log/measurement-logger.log&amp;lt;/file&amp;gt; &amp;lt;rollingPolicy class=&amp;#34;ch.qos.logback.core.rolling.FixedWindowRollingPolicy&amp;#34;&amp;gt; &amp;lt;fileNamePattern&amp;gt;../log/measurement-logger-%i.log&amp;lt;/fileNamePattern&amp;gt; &amp;lt;minIndex&amp;gt;1&amp;lt;/minIndex&amp;gt; &amp;lt;maxIndex&amp;gt;2&amp;lt;/maxIndex&amp;gt; &amp;lt;/rollingPolicy&amp;gt; &amp;lt;triggeringPolicy class=&amp;#34;ch.</description>
    </item>
    
    <item>
      <title>Automation Package Descriptor</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-yaml/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-yaml/</guid>
      <description>Automation Packages are defined in a declarative way using YAML alongside the automation code. The Step Automation Package YAML syntax is specified by the Automation Package JSON schema, for more convenient work you can configure the embedded file editor in your IDE (IntelliJ IDEA or Visual Studio) to associate this schema with the Step YAML automation packages.
For Java Automation Packages, it is possible to directly declare certain entities in the code in addition to the YAML descriptor.</description>
    </item>
    
    <item>
      <title>Maven plugin</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-cli/ap-maven-plugin/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-cli/ap-maven-plugin/</guid>
      <description>The Step Maven plugin serves as Command Line Interface (CLI) for all operations related to Automation Packages in Java. It provides an integration with the Step server and an easy way to integrate Step with a CI/CD pipeline. For non-Java projects, it is recommended to use the Step CLI.
The Step Maven plugin supports following operations:
Upload Automation Packages to Step and execute them in isolation Deploy the content of Automation Packages to Step and enable the contained schedules Deploy an Automation Packages library to Step You can choose to integrate the plugin goals during the package phase or any later phase as you see fit in the Maven Lifecycle.</description>
    </item>
    
    <item>
      <title>ALM</title>
      <link>https://step.dev/knowledgebase/30/plugins/hp_alm/</link>
      <pubDate>Wed, 10 Apr 2019 14:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/hp_alm/</guid>
      <description>The Micro Focus ALM integration plugin provides an out-of-the-box integration of Step with ALM.
With the ALM integration plugin you create, design and manage your automated test cases in ALM, run them on step&amp;rsquo;s Execution Engine, and evaluate the run results and test reports at the same place in ALM. This plugins is therefore the perfect solution for users requiring the best of the 2 worlds: the unique power of the Step Execution Engine with the test management and reporting features of ALM.</description>
    </item>
    
    <item>
      <title>Azure DevOps</title>
      <link>https://step.dev/knowledgebase/30/plugins/azuredevops/</link>
      <pubDate>Wed, 10 Apr 2019 14:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/azuredevops/</guid>
      <description>The Azure DevOps integration plugin provides an out-of-the-box integration of Step with the Azure Test Plans module of Azure DevOps.
With the Azure DevOps plugin you create, design and manage your automated test cases in Azure Test Plans, run them on Step&amp;rsquo;s Execution Engine, and evaluate the run results and test reports at the same place in Azure Test Plans. This plugins is therefore the perfect solution for users requiring the best of the 2 worlds: the unique power of the Step Execution Engine with the test management and reporting features of Azure Test Plans.</description>
    </item>
    
    <item>
      <title>Execution Subscriptions</title>
      <link>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/subscriptions/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/subscriptions/</guid>
      <description>From a user&amp;rsquo;s perspective, it is often useful to be notified about certain events, like the execution (or failure) of particular plans. This is possible by leveraging the functionality of the Alerting Rules and Notifications.
Expert users can create the corresponding rules themselves, however this is not necessarily a straightforward task, and figuring out the exact definitions may be cumbersome. Therefore, Step provides a simple Wizard which allows to set up notifications in an easy way.</description>
    </item>
    
    <item>
      <title>Automation Package Libraries</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-libraries/</link>
      <pubDate>Mon, 24 Nov 2025 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-libraries/</guid>
      <description>Overview Automation Package Libraries (AP Libraries) extend Step’s Automation Package model by enabling common code, libraries and entities to be packaged, deployed, and referenced independently from individual Automation Packages (APs).
They offer a structured mechanism for sharing logic at scale and optimizing performance across large automation ecosystems.
AP Libraries are reusable, versioned code artifacts that can provide:
Shared logic across multiple Automation Packages Common utilities and helper classes Shared libraries Shared AP entities (Keywords, Plans) Important:</description>
    </item>
    
    <item>
      <title>Automation Packages Multi-version support</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-multi-version/</link>
      <pubDate>Fri, 21 Nov 2025 07:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-multi-version/</guid>
      <description>Overview Step allows deploying multiple versions of the same Automation Package on a single Step instance. This is particularly useful when your system under test (SUT) exists in several versions across different environments (e.g., TEST, QA, PROD), each requiring a matching version of the automation code.
Multi-version support enables:
several versions of the same package to coexist automatic version selection at runtime consistent usage of keywords and plans from the selected version clear and predictable behavior across environments Step determines the correct version using activation expressions associated with each deployment.</description>
    </item>
    
    <item>
      <title>Step CLI</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-cli/step-cli/</link>
      <pubDate>Wed, 22 May 2024 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-cli/step-cli/</guid>
      <description>The Step CLI (Command Line Interface) is used for all operations with Step. It provides an integration with the Step server and an easy way to integrate Step with a CI/CD pipeline. Currently it is limited to the operations related to Automation Packages but might be extended in the future. For Java specific projects, the CLI is also available as a Maven plugin.
The Step CLI supports following operations for Automation Packages:</description>
    </item>
    
    <item>
      <title>Async packages</title>
      <link>https://step.dev/knowledgebase/30/plugins/async-event/</link>
      <pubDate>Wed, 10 Apr 2019 14:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/async-event/</guid>
      <description>Async and event-driven functionality is implemented in Step in the form of what we called the Event Broker, a central component allowing developers and plan users to manage the transmission of events, as well as a series of controls and built-in keywords.
Event Broker overview The basic semantics and the different means to access the broker are illustrated on the following figure:
The private members of the Event are as follows.</description>
    </item>
    
    <item>
      <title>Automation Package in Java</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-java/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-java/</guid>
      <description>Automation package entities can be defined in a declarative way with the automation package descriptor (YAML) as well as directly in the code for Java Automation Packages. This page focuses on the declaration of Automation Package entities in the code which is supported for Keywords and Plans.
Declaration of Keywords In addition to the declaration of Keywords in the automation package descriptor (YAML), Automation packages also fully support the Keyword API to declare Keywords directly in Java.</description>
    </item>
    
    <item>
      <title>Step client API</title>
      <link>https://step.dev/knowledgebase/30/devdocs/stepclient/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/stepclient/</guid>
      <description>The Java APIs and libraries (step Client) discussed in this section are currently only available in the step Enterprise Edition Introduction The Step client exposes means to connect to the controller programmatically, access and use Step services in a headless way. It also allows to execute locally Step controller functionalities like building and running a plan.
Resources: The Javadocs of the Step client is available here: step.client.StepClient and examples can be found on github.</description>
    </item>
    
    <item>
      <title>Agent provisioning</title>
      <link>https://step.dev/knowledgebase/30/userdocs/agent-provisioning/</link>
      <pubDate>Mon, 30 Sep 2024 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/agent-provisioning/</guid>
      <description>When running in Kubernetes, Step supports automatic provisioning of Agents (i.e. automatic provisioning of the containers responsible for executing Keywords) across multiple Kubernetes clusters. This page explains how to utilize Agent provisioning in Plans.
For information on enabling or configuring Agent provisioning, please refer to the Agent Provisioning configuration page.
How it works In a nutshell, the automatic Agent provisioning works as follows:
Upon execution, Plans are scanned to determine the required Agents for execution Based on the calculation and the available Agent pools, the optimal number of Agents per Agent pool is calculated The required Agents are provisioned across the clusters of the selected Agent pools Once the Agents have joined the grid, the execution starts After execution, the agents are de-provisioned Configure provisioning settings in Plans When Agent provisioning is enabled in Step, users can configure the Agent provisioning settings in each plan (in the UI and in the automation packages).</description>
    </item>
    
    <item>
      <title>REST API</title>
      <link>https://step.dev/knowledgebase/30/devdocs/rest-api/</link>
      <pubDate>Sat, 12 Jun 2021 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/rest-api/</guid>
      <description>Introduction While you can use the step client to interact programmatically with Step, it is also possible to use the Step&amp;rsquo;s REST API directly.
Note that the service signatures are more likely to change compared to the step client Documentation You will find the documentation of the REST API under the help menu of Step The documentation page provide the detailed specification of every services and means to directly invoke and test the service.</description>
    </item>
    
    <item>
      <title>Alerting and notifications</title>
      <link>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/</link>
      <pubDate>Mon, 17 Mar 2025 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/</guid>
      <description>Step includes a flexible mechanism for sending notifications in tandem with the definition of Alerting Rules, allowing to define exactly which events and conditions will result in which notification being sent.</description>
    </item>
    
    <item>
      <title>Event Broker API</title>
      <link>https://step.dev/knowledgebase/30/devdocs/eventbrokerapi/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/eventbrokerapi/</guid>
      <description>The Java APIs and libraries discussed in this section are currently only available in Step Enterprise Edition EventBroker The EventBroker Service and API allow asynchronous communication to happen in Step as well as synchronization between keywords, between plans and between keywords and plans. It is particularly useful in scenarios where a thread (or a &amp;ldquo;user&amp;rdquo;) needs to wait for specific events before performing the next task.
These events can be created internally (from within a keyword or plan) using various types of clients (Java, REST, prepopulated Keywords and Artefacts).</description>
    </item>
    
    <item>
      <title>Incidents</title>
      <link>https://step.dev/knowledgebase/30/userdocs/incidents/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/incidents/</guid>
      <description>Incidents are used to be aware of problems in the infrastructure: for instance, Step can periodically run plans which test the behavior of a system. When these plans fail to execute correctly, or (user-defined) assertions concerning the performance do not hold, this constitutes an incident.
Step allows incidents to be automatically created and managed according to user-defined alerting rules. These rules are evaluated in response to various events (most notably after every plan execution).</description>
    </item>
    
    <item>
      <title>Maven plugins</title>
      <link>https://step.dev/knowledgebase/30/plugins/maven-plugins/</link>
      <pubDate>Wed, 29 Mar 2023 08:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/maven-plugins/</guid>
      <description>The documentation of the Maven plugins was moved to the DevOps section and is available here.</description>
    </item>
    
    <item>
      <title>Artifact repository connector</title>
      <link>https://step.dev/knowledgebase/30/plugins/artifact-repository-connector/</link>
      <pubDate>Wed, 14 Oct 2020 08:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/artifact-repository-connector/</guid>
      <description>Description The artifact repository connector for Automation Packages provides a seamless integration with classical artifact repositories like Nexus. It enables the retrieval and execution of Automation Packages that are deployed on artifact repositories. The main use-case of this plugin is the integration with CI/CD pipelines. A common workflow relying on this feature looks as follows:
Development of Step Automation Packages along with the source code of the application to be tested Build of the Automation Packages as part of the CI pipeline and deployment of the Automation Packages to an artifact repository Trigger of the central execution of the Automation Packages on a Step Controller by the CI pipeline via artifact repository plugin Usage The artifact repository connector works like any other repository plugin like ALM, Jira, etc.</description>
    </item>
    
    <item>
      <title>Event Broker Monitor</title>
      <link>https://step.dev/knowledgebase/30/userdocs/eventbrokermonitor/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/eventbrokermonitor/</guid>
      <description>If you&amp;rsquo;ve purchased the Async package or are running the Premium Enterprise version of Step, you&amp;rsquo;ll be able to monitor in real time what&amp;rsquo;s happening in the EventBroker by navigating to the EventBrokerMonitor view:
The Stats tab provides global statistics on the broker, such as the current amount of messages present in it and the high mark (or water mark), oldest &amp;amp; youngest events, etc.
The next two tabs provide users with the ability to browse and search for events, and organizes the query results either by Id or Group.</description>
    </item>
    
    <item>
      <title>Analytics Integrations</title>
      <link>https://step.dev/knowledgebase/30/plugins/analytics-integrations/</link>
      <pubDate>Wed, 17 Mar 2021 14:24:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/plugins/analytics-integrations/</guid>
      <description>Step records measurements and metrics for every execution and makes them available through its built-in analytics stack. For organizations that want to feed this data into their own monitoring stack such as Grafana, Splunk, or a custom SQL database, we provide a set of enterprise plugins that export data to external systems in real time.
The following integrations are available:
Integration Plugin class name Data written Enabled by default JDBC (SQL) JdbcMeasurementControllerPlugin Measurements No Prometheus PrometheusControllerPlugin Measurements + Metrics Yes Metrics Logger MetricsLoggerControllerPlugin Measurements + Metrics No Data export takes effect for new executions once the plugin is enabled.</description>
    </item>
    
    <item>
      <title>Versioning</title>
      <link>https://step.dev/knowledgebase/30/userdocs/versioning/</link>
      <pubDate>Sun, 29 Nov 2020 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/versioning/</guid>
      <description>Versioning is a feature to restore a previous version of an entity in Step Enterprise. This can be helpful to undo unintended changes or to revert a breaking change.
How versioning works in Step Versioning is currently supported for the following entities:
Plan Parameter Step automatically saves changes to these entities, aggregated to 1-minute intervals. This aggregation ensures, that a lot of small changes within a minute will only show as one change in the version history.</description>
    </item>
    
    <item>
      <title>AI</title>
      <link>https://step.dev/knowledgebase/30/ai/</link>
      <pubDate>Wed, 03 Jun 2026 11:00:00 +0200</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/ai/</guid>
      <description>This section is dedicated to AI-powered testing with Step. It covers the technologies, workflows, and capabilities that enable autonomous software testing across functional testing, load testing, and monitoring. Whether you are exploring AI-assisted test development through the Step MCP Server, leveraging Reusable Testing Skills, or adopting the Step Testing Agent, this documentation explains how Step integrates large language models (LLMs) into existing testing and CI/CD workflows. The goal is to help teams accelerate automation creation, reduce maintenance effort through self-healing capabilities, and deliver reliable, reproducible testing outcomes at scale.</description>
    </item>
    
    <item>
      <title>Automation Package CLI</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-cli/</link>
      <pubDate>Wed, 21 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-cli/</guid>
      <description>Automation Packages come with a full-featured CLI that allows to build, execute and deploy Automation Packages. The CLI is available as native application for Windows and Linux, and as Maven plugin which is recommended for integration with Java projects.</description>
    </item>
    
    <item>
      <title>DevOps</title>
      <link>https://step.dev/knowledgebase/30/devops/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/</guid>
      <description>This section is dedicated to use of Step in the DevOps context. It targets developers who want to define their software automation artifacts for the whole DevOps lifecycle as code alongside their product code.</description>
    </item>
    
  </channel>
</rss>
