Getting Started for Plugin and Integration Developers
Plugin and integration developers extend Digital.ai Release by building custom plugins, calling the REST API, automating Release configuration as code, and integrating Release with AI agents via the MCP Server. This guide covers the available development approaches, SDKs, API references, and automation tools.
This guide assumes that Digital.ai Release is already installed. For building and testing container-based plugins, you also need a Release Runner instance. If you need to set up Release, see the Installation Guide. To deploy Release Runner, see Getting Started for System Administrators.
Who This Guide Is For
This guide is for users who:
- Build custom container-based plugins using the Python SDK or Go SDK.
- Build JVM-based plugins using the Jython SDK.
- Call the Release REST API from external systems or scripts.
- Automate Release configuration using the XL CLI and DevOps as Code (YAML).
- Integrate Release with AI agents using the Release MCP Server.
For configuring existing integrations and setting up automated tasks in pipelines, see Getting Started for DevOps and Pipeline Engineers.
Choose Your Development Path
Start with the goal that matches what you need to build.
| Goal | Recommended Approach | Runtime | Start Here |
|---|---|---|---|
| Build a new custom task or integration | Python SDK | Container through Release Runner | Python SDK Overview |
| Build a Go-based integration | Go SDK | Container through Release Runner | Go SDK Overview |
| Add custom UI screens, REST endpoints, or event listeners | JVM Plugin SDK | Release server JVM | JVM Plugin SDK |
| Control Release from another system or script | REST API | External HTTP client | REST API Reference |
| Run automation inside a release pipeline | Script or webhook tasks | Release task runtime | API and Scripting Overview |
| Manage Release configuration as code | DevOps as Code | XL CLI | Get Started with DevOps as Code |
| Connect Release to AI agents | MCP Server | Built into Release | Release MCP Server Overview |
When Should You Build a Plugin?
You do not need a plugin for every integration. Start with the simplest option that fits the job.
| Need | Use |
|---|---|
| Call an HTTP or SOAP endpoint from a pipeline | Webhook Task |
| Run small inline automation inside a pipeline | Jython Script Task |
| Run Python 3 automation in a container | Python 3 Script Task |
| Run a command on a remote host | Remote Script Task |
| Control Release from another system or script | REST API |
| Reuse and distribute custom task types | Python SDK, Go SDK, or JVM Plugin SDK |
| Manage templates, folders, connections, variables, and releases as code | DevOps as Code |
| Connect Release to MCP-compatible AI agents | Release MCP Server |
Build a plugin when the integration must be reusable, packaged, versioned, shared across teams, or exposed as a typed task in Release.
Choosing a Plugin SDK
Digital.ai Release supports three plugin development models.
| Approach | Language | Runs On | Use When |
|---|---|---|---|
| Python SDK | Python 3 | Container through Release Runner | You need a new custom task or integration. Recommended for most new plugins. |
| Go SDK | Go | Container through Release Runner | You need a Go-native or performance-sensitive integration. |
| JVM Plugin SDK | Jython 2.7 | Release server | You need server-side extensions such as custom UI screens, REST endpoints, event listeners, or synthetic properties. |
Container-based plugins (Python SDK and Go SDK) require a container runtime such as Docker or Kubernetes to execute tasks. This is handled by Release Runner, a separate component that runs alongside the Release server. For more information, see Overview of Release Runner.
For scripting within existing tasks rather than building a full plugin, see Release Automation.
API Reference Documentation
The following API references are available for Release 26.3:
| Reference | URL |
|---|---|
| REST API Reference | REST API Docs |
| Jython API Reference | Jython API Docs |
| Python API Reference | Python API Client Docs |
| DSL API Reference | DSL API Docs |
For an overview of all developer resources, see API Docs.
Release Automation
Release provides several ways to automate tasks and interact with third-party systems from within the Release UI, without building a full plugin.
REST API
The REST API is the primary way to control Release from external systems. It exposes core Release functionality over HTTP, with data exchanged in JSON format. Use it to start releases, complete tasks, add comments, query release status, and more.
- REST API Reference
- Create a New Release via REST API
- How to Find Identifiers for REST API
- Troubleshoot the API
Jython Script Tasks
Use a Jython Script Task to run a Jython 2.7 script inline within a release pipeline. The script has access to the Release Jython API and the full Java API. Use this for lightweight automation that does not require a container or a full plugin.
For available helper functions, see Additional Jython Helper Functions and Using the Release API in Scripts.
Webhook Tasks
Use a Webhook Task to call any HTTP endpoint (REST or SOAP) from within a release pipeline. Parse the response into a Release variable for use in subsequent tasks. No scripting required.
Python 3 Script Tasks
Use a Python 3 Script (Container) task to run a Python 3 script in a container through Release Runner, with direct access to the Release API and current-context helpers. Use this to replace Jython Script Tasks with a modern, actively supported runtime. See Migrate Jython Script to Python 3 Script (Container).
Remote Shell Script Tasks
Use a Remote Script Task to execute a shell script on a remote host. Both Unix and Windows are supported.
For a full overview of all automation options, see API and Scripting Overview.
DevOps as Code
DevOps as Code lets you define Release configuration (templates, folders, connections, variables, and releases) as YAML files and apply them using the XL CLI. This enables version-controlled, code-reviewed, and repeatable management of Release configuration.
XL CLI
The XL CLI (xl) is the command-line interface for DevOps as Code operations.
YAML Format
Release configuration is expressed in a YAML format understood by the XL CLI.
Blueprints
Blueprints are parameterized YAML templates that generate Release configuration from a set of inputs. Use them to scaffold standard release pipeline configurations on demand.
Python SDK
The Python SDK lets you build container-based plugins in Python 3. Each plugin packages one or more custom task types that run as containers via Release Runner.
How It Works
- Task definitions are declared in a
type-definitions.yamlfile (YAML format, recommended) or asynthetic.xmlfile. - Task logic is written in Python 3 and packaged with a Docker image.
- The plugin runs as a container orchestrated by Release Runner, isolated from the Release server.
- The SDK includes a pre-configured Docker-based development environment with a fully functional Release instance and a limited license for local testing.
Prerequisites
- Docker (for the development environment)
- Python 3
- Access to a Release Runner instance for testing container tasks
Getting Started
Start from the Python SDK template project on GitHub, then review the Python SDK Overview to understand the project structure and plugin definition format.
The template includes a Docker Compose development environment with a fully functional Release instance. Use it to test drive your plugins locally before publishing them. For more information, see Build a Custom Container Plugin using the Python SDK.
Release API Client
When a plugin task needs to call back to the Release server, such as to read or update release variables, query task status, or interact with other releases, the Python SDK provides a Release API client to handle this. The current client provides convenience methods for authentication around a standard HTTP library. For implementation details, see Release API Client.
Go SDK
The Go SDK lets you build container-based plugins in Go. Like the Python SDK, plugins run as containers via Release Runner.
Prerequisites
- Go 1.20 or later
- Access to a Release instance
- Access to a Release Runner instance for testing container tasks
Getting Started
Start from the Go SDK template project on GitHub and add the SDK as a dependency:
go get github.com/digital-ai/release-integration-sdk-go
Review the Go SDK Overview for project structure and key features, then follow the step-by-step walkthrough in Build a Custom Container Plugin using the Go SDK.
Key Features of the Go SDK
- REST client with authentication (username/password and API key), automatic retries, and error handling.
- APIs for templates, folders, releases, configuration, and variables.
- Git operations support for interacting with local and remote repositories.
JVM Plugin SDK (Jython)
The JVM Plugin SDK lets you extend the Release server directly using Jython scripts. Use it when you need to add custom UI screens, declare new REST endpoints, listen to server-side events, or define synthetic properties. These capabilities require direct access to the Release runtime.
Jython scripts use Python 2.7 syntax. This is a constraint of the Jython runtime, which runs Python code on the JVM to enable direct Java API calls. If Python 3 syntax is a requirement, use the Python SDK instead.
How It Works
- Extensions are packaged as
.jarfiles placed in the Releasepluginsdirectory. - XML descriptor files register endpoints and UI components with the Release server.
- Jython scripts run on the Release server JVM using Jython 2.7. The full Java API is also available within scripts.
Key Extension Points
| Extension Point | What It Does | Guide |
|---|---|---|
| Custom UI screens | Add new menu items and screens to the Release UI | Extend the Release User Interface |
| Custom REST endpoints | Create new API endpoints backed by Jython scripts | Declare Custom REST Endpoints |
| Event listeners | Register listeners that respond to system events | Listen to Events |
| Synthetic enum properties | Define new enum property types for tasks and connections | Defining a Synthetic Enum Property |
For the full JVM Plugin SDK reference, see JVM Plugin SDK (Jython).
Release MCP Server
Digital.ai Release includes a built-in Model Context Protocol (MCP) server, bundled by default through the Release MCP Tools Plugin. It powers AI Assistant and lets any MCP-compatible client, such as Claude Code, Cursor, Claude Desktop, Visual Studio Code, or GitHub Copilot, interact with releases, templates, tasks, and variables using natural language.
No separate installation is required. The MCP server is enabled by default, and an administrator can enable or disable it in System Settings > AI Settings. To connect an external AI agent, generate a personal access token and use the connection snippet on the MCP Server settings page.
Key Capabilities
- Release Management: Create, search, count, and manage releases.
- Template Operations: Design, review, and optimize release templates with AI guidance.
- Task and Phase Management: Add, update, convert, and delete tasks or phases.
- Configuration Management: Integrate with external systems, such as Jenkins, Jira, and Git, and manage configuration objects.
- Variable Management: Manage variables across global, folder, release, and template scopes.
- Monitoring and Analysis: Retrieve activity logs, analyze failures, and get AI-powered root cause suggestions.
- Read-only Mode: Explore and analyze the Release environment without making changes.