Introduction to Flow Pilot

                 Flow Pilot delivers a modern, AI-enabled development experience for IBM webMethods Integration while maintaining full compatibility with existing flow services. Use IBM Bob, Github Copilot or Claude or other enterprise-approved AI assistants that align with your organization’s strategy, security and governance policies without being locked into a single vendor-native experience.

 Key capabilities include in the current release:

• Flow Script Language (FSL): A simplified, developer-friendly alternative to the traditional XML-based flow service representation.
• Service Designer Support: Create new flow services in FSL while retaining backward compatibility with existing services.
• Integration Server Support: IBM webMethods Integration Server can create, understand, and execute both FSL-based and traditional flow services.
• AI Skills: Ready-to-use skills that work with IBM Bob and other AI tools to help generate FSL, documentation, and test scripts.
• VS Code Extension (Preview): Modern development experience with support for AI-assisted development, deployment, and management of FSL-based services. 

Key Features

• Use natural-language prompts to create and improve webMethods Flow Services, helping developers move faster from integration intent to implementation.
•  Create documentation, parameter descriptions, flow diagrams directly from the AI generated service using the prompts.
•  Create test suite and test scenarios directly using prompt to reduce manual effort and then import the test suite inside the designer.
•  Review existing flow services and integrations which has been there for a long and create automated documentation to easily understand the flow.
•  Apply logging, error handling, coding standards and reusable pattern guidance earlier in the development lifecycle to improve consistency across teams.

Flow Script and AI-assisted development

                Flow Script is designed to work with generative AI tools such as GitHub Copilot and IBM Bob. Its structured plain text format and predictable syntax enable AI tools to generate valid Flow Script from natural language prompt. You can describe a Flow Service requirement using prompt inside your AI tool, and Flow Pilot will generate a complete Flow Script(.flow) file.

                   Once Flow Script (.flow) file is generated it can be deployed to an Integration Server directly from AI assistant using VS Code Deploy command or by copying the .flow file inside the Integration Server Packages directory as per specified package path. After copying the .flow file you can reload the package from designer or IS Admin and the flow service will get generated instantly inside the package along with flow.xml file in the backend file structure.

Example:

The following flow service contains flow.flow and flow.xml files -

Flow Script Structure:

A Flow Script file has three main sections:

interface <namespace>                                                   // 1. Namespace declaration

service <name> (<signature>)                                      // 2. Service declaration with I/O signature

properties {...}                                                                    // 3. (optional) Service-level metadata

{                                                                                             // 4. Service body — ordered list of steps

<steps...>

}

Example:  flow script (.flow) file which performs addition of two numbers -

interface demo.utils
service addNumbers (
    input {
        String num1;
        String num2;
    }
    output {
        String `output`;
    }
)
properties {
    favorite: false;
    deprecated: false;
    visible: private;
    reuse: private;
    pipelineDebug: None;
    enableAuditing: never;
    logOn: Error only;
    includePipeline: never;
    circuitBreakerEnabled: false;
    failureEvent: Exception only;
    timeoutPeriod: 60;
    cancelThreadOnTimeout: false;
    failureThreshold: 5;
    failurePeriod: 60;
    circuitOpenAction: Throw exception;
    circuitResetPeriod: 300;
    concurrencyEnabled: false;
    maxConcurrentRequests: 20;
    validateInput: false;
    validateOutput: false;

}

{

    MAP {
        TRANSFORM pub.math:addInts {
            invoke-order: 0
            validateInput: false
            validateOutput: false
            input {
                copy `num1` -> `num1`;
                copy `num2` -> `num2`;
            }
            output {
                mapTarget {
                    String `output`;
                }
                copy `value` -> `output`;
            }
        }
    }
}

     

For more details about flow script language specification and syntax refer the documentation link: https://www.ibm.com/docs/en/webmethods-integration/wm-designer/12.1.0?topic=script-flow-language-specification 

Pre-requisite:

• IBM webMethods Service Designer 12.1 with below fixes 
•  Integration Server Core Fix2 or later for 12.1
•    Service Designer Core Fix2 or later for 12.1
•     Flow Pilot Skills & VS Code Extensions zip file·
•    An AI assistant tool e.g. IBM Bob, Github Copilot or Claude etc.

Installation and Setup guide

Step 1. Install Service Designer v12.1.x with Flow Pilot:

                                 IBM webMethods Service designer v12.1.x comes with Flow Script Language (FSL) which is a modern, text-based language for building Integration Server flow services. To download webMethods Service Designer v12.1.R02 use below link which contains local Integration Server with Core Fix2 along with Service Designer Core Fix2 :

Link:   https://www.ibm.com/resources/mrs/assets/DownloadList?source=WMSD_FlowPilot&lang=en_US#lang=en_US 

After downloading the wMServiceDesigner zip file, unzip it using the tools such as 7Zip and launch ServiceDesigner. Once Service Designer is launched, start local integration server.

Step2. Install Flow Pilot Skills & VS (Visual Studio) Code Plugin:

                               webMethods Integration Flow Pilot extension integrates AI assistant capabilities into Visual Studio Code, enabling developers to generate, validate, and deploy IBM webMethods Integration Server assets by using natural language. To support AI-assisted development using flow script language (.flow), Integration Server provides flow-pilot package (ZIP file), which includes the following resources:

Grammar files   

               The formal language specification that defines every valid Flow Script construct, keyword, and syntax rule.

 Example: FlowService.g4 grammer file -

AI skills

                   Ready-to-use instruction files that you load into an AI tool such as GitHub Copilot or IBM Bob. These instruction files guide AI tools to generate correct Flow Script and avoid common errors.

Service catalogs

                    Structured descriptions of the built-in services available in Integration Server. These files ensure that the AI references only services that exist, with the correct names and parameters.

Example Flow Script files

                      A library of working .flow files that demonstrate every flow step type. These examples show AI tools what correct Flow Script looks like for a wide range of scenarios.

• The Flow Pilot skills along with VS Code extension can be downloaded using below link-
  https://www.ibm.com/resources/mrs/assets/DownloadList?source=WebMtds_FlowPilot&lang=en_US

The Skill File Contains below folders -

• After downloading the file, unzip the 'wm-integration-flow-pilot-12.1.0.2' file and go to your preferred AI assistant tools such as IBM Bob, GitHub CoPilot or Claude Code. For demonstration we will be using IBM Bob. 
• In IBM Bob navigate to File ->Open Folder and select the folder wm-integration-flow-pilot-12.1.0.2.  Bob will load all the files of the folder as below -

Visual Studio (VS) Code Extension 

                      Visual Studio Code extension packages the AI skills and connects directly to a running Integration Server instance. The extension provides the following capabilities:

1. Automatically installs webMethods Flow Pilot AI skills into AI IDE such as Bob inside your workspace.
2. Connects to an Integration Server from Visual Studio Code to create packages and folders, deploy FlowServices, validate Flow script, and execute services using commands inside IDE.

To install Flow Pilot skills using Visual Studio Code Extension:

• Open the Extensions view inside Bob and click 3 dot …
• Select Install from VSIX…
•  Navigate to the folder  …/wm-integration-flow-pilot-12.1.0.2/VSCodeExtension and select ‘wm-integration-flow-pilot.vsix’ file and click Install.

         After installation, the extension activates automatically and installs skills into Bob on restarting it.

• Click on Extension icon again and under INSTALLED we will be able to see webMethods Integration Flow Pilot skills which means installation has been successful.

Flow Service generation using AI assistant

This practical demonstration explores how to generate a webMethods flow service in an AI assistant tool such as Bob from natural language prompt by using the Flow Pilot Skills. The process begins by providing the service requirements, including the expected input and output parameters. Based on the prompt, the AI assistant generates the Flow Service definition and corresponding .flow script file. The generated artifact (.flow file) can then be deployed directly to a local Integration Server. Finally, we will explore how AI can also be leveraged to automatically generate comprehensive documentation for the webMethods Flow Service.

Steps :

• In Bob navigate to File->Open Folder and go to 'C:\Designer121\wMServiceDesigner\IntegrationServer\packages' directory of your designer installation file. This will load all the packages into Bob workspace. which makes it easy for Bob to read all the Integration Server packages and its folders location when generating the flow services. And Bob can directly generate a flow service into the Integration Server package/folder path specified during prompt.

• Go to webmethods Designer and create a folder for e.g. ‘demo/coe’ inside a package as below - 

•          In Bob go to prompt window and select Agent mode and provide below prompt for example, to generate a flow service -

Prompt:   

• Bob will start loading all the reference documents from the webMethods integration skills file for Flow Script generation. It reads all the grammar files, flow script example files, built in services syntax  after carefully examining each and every keyword in the prompt and finally generates the flow.flow file and writes it to Integration Server packages folder inside the path 'DemoPack/ns/demo/coe/getMatchedItems/flow.flow' after completing all the compliance checks and validations.

          Bob Logs -

• Open webMethods designer 12.1 and reload the package 'DemoPack' and you will be able to see the Flow service 'getMatchedItems' is generated under 'demo/coe' folder as shown below: 

The generated service has below Input/Output parameters as per the Input/Output tab -

• Test flow service in designer:    

                      The generated flow service ‘getMatchedItems’ can be tested in designer by running the service with below inputs -

           Provide Service Input parameter values and run the flow service:

        Results -

                The Results contains the ‘matchedItems’ output list which has 2 items in status ‘active’ and where orderLine matches the lineNum of requestDocument. Hence the test results validation is successful.

        Key Points to note – 

1. The generated flow service has a new tab ‘Source’ which contains the source code of flow script file (.flow). The flow script can be copied to a plain text editor like notepad and can be edited to modify the service logic in plain text and paste the modified logic back into the Source tab. After saving the changes in Source the Integration server will dynamically update the flow.xml in the backend and changes will be visible in Tree view instantly.

       2.  The backend file structure of the flow service 'getMatchedItem' contains both flow script file (flow.flow) as well as flow.xml file as shown below:

 Flow Service documentation using AI assistant

To generate the Flow service documentation using AI assistant, provide the prompt as below –

Prompt: Please generate documentation for the flow service ‘getMatchedItem’

Bob will create a markdown (.md) file with the documentation and flow diagram of the flow service as below:

Right click on getMatchedItems.md file and click Preview .

The preview will show the documentation of the flow service with input/output parameters, data types, Flow diagram and usage examples:

Flow Diagram:

Disclaimer

1)IBM continue to enhance and refresh Flow Pilot skills and tooling based on feedback from customers and users, helping drive even greater productivity and innovation in future releases.

2) The initial focus of the repository is the Flow Script Language (FSL), a domain-specific language (DSL) for generating Integration Server Flow Services. The repository will expand to support additional Integration Server asset types, including document types, Java services, adapters, triggers, schemas, and other development artifacts with future releases or fixes.

#References:

https://www.ibm.com/products/webmethods-integration/flow-pilot

https://www.ibm.com/new/announcements/introducing-ibm-webmethods-integration-flow-pilot-navigating-integration-development-at-ai-speed

#IBM Flow Script Documentation:

https://www.ibm.com/docs/en/webmethods-integration/wm-designer/12.1.0?topic=help-flow-script