This use case demonstrates an end-to-end, AI-assisted integration workflow leveraging IBM Bob (configured with a specialized ACE Developer custom mode) alongside IBM App Connect Enterprise (ACE) v13.

In this scenario, an integration developer utilizes IBM Bob’s chat interface inside the Bob IDE to automatically generate, build, and locally test a production-ready REST API. The generated API connects to an open-source backend weather service to expose two distinct endpoints (/weather/current and /weather/alerts). The solution also demonstrates an optional enterprise-grade governance extension where the completed App Connect Enterprise BAR (Broker Archive) file is deployed, monitored, and managed via the IBM webMethods Hybrid Integration (IWHI) Hybrid Control Plane.

The AI-powered dynamic pricing and offer optimization system bridges the gap between fragmented historical data and fast-changing market dynamics by merging batch intelligence with real-time decisioning. The system establishes a baseline pricing foundation from historical demand patterns and user behavior, then instantly adapts prices and promotions based on live signals like demand spikes, inventory changes, and group sizes. Tailored specifically across industries—delivering dynamic rates in retail and hospitality, and personalized bundles in food and beverage—the solution optimizes revenue during critical peak windows and attracts customers during low-demand periods. Crucially, the system communicates why prices are changing, ensuring transparency that preserves customer trust while maximizing revenue potential.

IBM Bob accelerates building Agentic AI powered Insurance Claims process powered by IBM watsonx Orchestrate, IBM WebMethods Hybrid Integration (IWHI) and HashiCorp Vault.

IBM Bob accelerates building autonomous thread remediation solution powered by watsonx Orchestrate, Guardium, Vault and Verify. This use case showcases an autonomous, intelligent, and self-healing workflow powered by Agentic AI (via IBM watsonx Orchestrate) working collaboratively with specialized security tools to detect, investigate, and remediate internal security breaches in real time. In the simulated scenario, a malicious internal actor exploits an application loophole, steals authentication credentials from HashiCorp Vault, and bypasses traditional security checks by impersonating an authorized application. Posing as the app, they manipulate IBM Verify and execute quiet, scripted database queries to extract sensitive customer and financial data while attempting to blend into normal system traffic.

This solution leverages IBM watsonx.data and IBM Bob to build an AI-powered fraud detection platform. IBM watsonx.data provides a unified lakehouse that consolidates structured transaction data, customer interactions, and external intelligence such as dark web monitoring for real-time analytics. IBM Bob acts as an intelligent operations hub, integrating fraud alerts, automating investigation workflows, and providing AI-driven recommendations through a centralized dashboard, enabling faster and more accurate fraud detection and response. The solution architecture also integrates an MCP Server to facilitate seamless interaction between users, IBM Bob, and the unified data platform.

This case study demonstrates the implementation of a real-time credit card fraud detection system using Confluent Kafka Community Edition on Red Hat Enterprise Linux (RHEL). The solution processes credit card transactions in real-time, identifying fraudulent patterns with sub-second latency, enabling immediate action to prevent financial losses.

This demo showcases how IBM Bob, connected to IBM Planning Analytics via Planning Analytics MCP server, enables healthcare finance teams to connect to TM1 server, query cubes, analyse multi-dimensional data, and generate executive-ready insights — all through natural language queries.Using a Healthcare dataset on the TM1 server (7 cubes including Revenue HC, P&L HC, and Employee Expenses HC), the demo follows a real analyst workflow: discovering available data, analysing costs and revenue drivers, diagnosing forecast accuracy gaps, modelling what-if scenarios, and generating a comprehensive executive report.

IBM Bob accelerates the creation of SRE Agents that integrate with a customer’s existing IT operations tools, solving complex issues in a governed and fully auditable manner.

ParkBot Assist leverages AI agents to process natural language requests and securely complete time-bound parking bookings via live integrations with the watsonx.data lakehouse.

This use case outlines the comprehensive application modernization journey of a legacy enterprise IBM i application (represented by the SAMCO/Flight400 environments). Utilizing the IBM Bob Premium Package for i (PPi)—an AI-powered, expert-mode assistant embedded within a modern VS Code-based integrated development environment (IDE)—a development team transitions an older application from green-screen legacy development to modern, DevOps-driven practices. The transformation spans every critical phase of modernization, including automated code exploration, fixed-to-free RPG conversion, database re-engineering (DDS to SQL), full-stack impact analysis, and automated unit testing, while smoothly bridging the gap between host-based source libraries (QSYS) and Git-managed workspaces.

Lakehouse Copilot transforms how you work with data by allowing you to create, manage, and analyze your Lakehouse through natural language—driving faster insights and eliminating manual, code-heavy workflows.

This asset leverages IBM Bob to rapidly build multi-agent financial planning systems using IBM watsonx Orchestrate ADK. IBM Bob automates the entire development lifecycle from architecture design to code generation, deployment automation, and documentation transforming weeks of expert-level work into hours of AI-assisted development. The solution demonstrates how AI can democratize complex agentic system creation, delivering production-ready, ADK-compliant multi-agent systems with 10x faster development speed and zero rework.

Manually analyzing APIs for migration complexity is time-consuming and error-prone. Teams have to inspect specifications, policies, and backend dependencies one by one, making it difficult to get a complete and consistent view, leading to underestimation of effort. In platforms like IBM API Connect, complex assemblies and environment-specific configurations further increase the difficulty. As a result, manual analysis slows down decision-making, introduces inconsistencies, and raises the risk of migration failures or rework. In this demo, we will use IBM Bob to generate comprehensive Migration analysis report for v5 to v10 Datapower API gateway including recommendations and best practices.

This demo showcase an end-to-end API lifecycle automation workflow using AI and IBM API management capabilities. It covered generating an enterprise-grade OpenAPI specification, validating it against OWASP security standards, automatically generating and deploying the backend implementation on IBM Cloud Code Engine, and updating the API specification to integrate with the deployed backend services. It also highlights the integration of API Connect MCP Server with Bob to streamline API management activities such as listing projects, creating and deploying APIs, and testing APIs directly within API Connect. Overall, the solution demonstrates how AI-driven automation can accelerate secure API development, deployment, governance, and testing in an enterprise environment.

This use case outlines how an enterprise IT organization uses IBM Bob to automate the syntax transformation and documentation of core legacy RPG (Report Program Generator) applications running on the IBM i platform. In this scenario, application developers leverage Bob within their localized development workspace to ingest ancient, column-specific Fixed-Format RPG source code. The AI agent acts as a specialized technical translator: it analyzes the code, produces human-readable markdown documentation detailing its functional logic, and automatically refactors the codebase into modern Free-Format RPG syntax without altering the underlying business rules.

This use case outlines how an enterprise software engineering team utilizes IBM Bob configured in MCP (Model Context Protocol) Mode to automate the reverse-engineering, analysis, and architectural modernization of legacy monolithic IBM i applications (such as COBOL or RPGLE programs). By deploying a dedicated MCP server acting as a secure real-time gateway, an autonomous AI agent is given safe, read-only operational context directly into the live IBM i partition. Instead of working on disconnected code snippets, the AI operates as an intelligent co-developer that can actively cross-reference active source files, system object descriptions (*PGM, *FILE), live Db2 schema catalogs, and program error logs to orchestrate a systematic step-by-step application transformation.

This use case outlines the foundational setup, preparation, and pilot phase executed by an enterprise IT department adopting IBM Bob to drive large-scale, automated application modernization initiatives on the IBM i platform. It details how engineering teams establish a standardized workspace sandbox, configure essential local environment tooling (such as Visual Studio Code extensions for IBM i or Rational Developer for i), and execute their first benchmark validation test using Lab 1: RPG Fixed-to-Free Conversion. By systematically proving out the toolchain on a controlled set of legacy column-specific Fixed-Format RPG source members, the organization validates the AI agent’s accuracy and establishes a repeatable blueprint for company-wide code modernization.

This use case demonstrates how a development team uses IBM Bob to quickly prototype and build standard data-driven business applications—specifically a web-based Article/Product List display—that interacts directly with foundational IBM i backend data structures. Instead of writing boilerplate database access code and data mapping functions by hand, developers use Bob to interpret raw data layouts, generate modern display logic, and assemble the microservices or UI components needed to serve a clean, scannable item catalog to end users.

This use case outlines how an enterprise database and application development team utilizes IBM Bob to automate the migration of database access logic from archaic Record-Level Access (RLA) commands—such as legacy RPG operations like CHAIN, SETLL, READE, or native logical file overrides—into modern, standardized Embedded SQL statements. Developers leverage the AI agent within their local workspace to ingest legacy data-access layers, automatically analyze the underlying relational pathways, and systematically refactor the application to use standardized SQL queries that execute natively against the advanced Db2 for i query engine.

This use case outlines how a cross-functional enterprise IT team (comprising architects, newly hired developers, and product owners) uses IBM Bob to perform automated, comprehensive code discovery and application mapping on SAMCO—a massive, monolithic, and undocumented legacy business application running on the IBM i platform. Instead of spending weeks manually tracing control flows or deciphering complex source physical files (QSYS.LIB), developers task the AI agent with reading the entire codebase. Bob ingests the legacy structures, reverse-engineers the system’s operational architecture, and builds an exhaustive functional profile of the SAMCO application natively within the workspace.

The flight400-demo is a baseline application and architectural template designed to illustrate the progressive modernization of legacy applications on the IBM i (AS/400) platform. Centered around a mock flight booking/management system, this repository serves as a hands-on proof of concept (PoC). It showcases how monolithic RPGLE code and DB2 for i databases can seamlessly interface with modern DevOps build tools (such as “Bob” / Better Object Builder), CI/CD pipelines, and microservices/web components without forcing a risky or costly total platform rip-and-replace.

This use case demonstrates how an enterprise development team utilizes IBM Bob to handle advanced Fixed-Format to Free-Format RPG conversion on the IBM i platform, specifically addressing complex, deprecated code structures like Output Specifications (O-Specs). Instead of executing a simple text-string replacement, the developer gives Bob architectural rules on how to modernly refactor the old layout. The AI agent reads the heritage code, extracts the archaic, embedded output printing configurations, isolates them into standalone modern Print Files, and automatically converts the main program logic line-by-line into clean, readable, fully Free-Format RPG syntax.

This use case demonstrates how an enterprise development team utilizes IBM Bob to engineer a complete, multi-tier Student Management Application from scratch natively on the IBM i platform. Instead of forcing separate teams to spend weeks hand-coding standalone layers, a single engineer leverages Bob as an autonomous full-stack partner. The AI agent takes high-level application specifications and systematically builds out every tier of the software lifecycle: generating a comprehensive structural design document, spinning up the foundational Db2 database layers, coding modern Free-Format RPG business logic, building a Python Flask REST API middleware tier, and delivering a responsive web-based HTML5 frontend

This use case outlines how an enterprise IT department utilizes IBM Bob to autonomously extract, map, and document the complete functional architecture of an exceptionally old, large-scale RPG II / RPG III (RPG/36) Enterprise Resource Planning (ERP) application running on the IBM i platform. Instead of relying on manual code reviews to track decades of legacy systems, developers instruct Bob to scan the entire workspace—including Control Language (CL) programs, physical and logical files, printer overrides, DDS schemas, panel groups, and massive volumes of legacy RPG code. Working as an advanced repository intelligence agent, Bob builds an operational blueprint of the software, generating an exhaustive documentation package containing high-level executive summaries, library mappings, data flows, and structural business rule diagrams.

This use case outlines how an application developer or maintenance engineer uses IBM Bob to automatically analyze and insert meaningful, human-readable documentation directly inside legacy Fixed-Format RPG source files. In this scenario, the developer directs Bob to scan a completely undocumented, column-specific RPG/RPG II program inside their local development workspace. Operating line-by-line, Bob functions as a code analysis partner, breaking down archaic variable definitions, input/output sections, and procedural indicators to inject descriptive context comments inline without modifying the operational mechanics of the code.

This use case demonstrates how an application developer utilizes IBM Bob to autonomously refactor old, cryptic variable names within a legacy RPG program to make the codebase modern and easily readable. In this scenario, the developer is working with a typical enterprise IBM i application that features a hybrid mix of classic Fixed-Format and modern Free-Format RPG specifications. The developer instructs Bob to pinpoint, analyze, and rename internal program variables—transforming short, ambiguous characters into clear, human-readable terms—without altering the underlying business logic or breaking links to external database fields.

The IBM Bob Java Modernization Workflow (Java Upgrade Path) provides an end-to-end, AI-driven automation process for upgrading legacy Java applications (e.g., legacy Java 8 applications using Struts 2 running on IBM WebSphere) to modern Java versions (such as Java 21) and updated runtime specifications like Jakarta EE 10.

The solution establishes a clean build baseline, checks system tooling (e.g., SDKMan), applies automated OpenRewrite AST refactoring recipes to source code and POM dependencies (migrating javax to jakarta), detects build and transitive dependency incompatibilities (such as outdated Javassist versions), and suggests targeted fixes. It validates the builds, automatically commits changes to dedicated Git branches, and generates an auditable Mermaid diagram documenting the entire migration process

IBM Bob’s Java Modernization Premium Package demonstrates end-to-end automated replatforming of a legacy enterprise Java application — a Pharmacy Dashboard built on Java 8, Struts 2 MVC, and IBM WebSphere Application Server Traditional — to a modern, cloud-native stack running on Java 21 and IBM WebSphere Liberty, complete with a production-ready container image. The workflow is driven by the Bob Unified Agent Harness inside the IDE, augmented by output from the Application Modernization Accelerator (AMA), and covers the full lifecycle: project analysis, automated code transformation via OpenRewrite recipes, AI-driven resolution of critical dependency violations, live local deployment validation, and a clean Git audit trail — all without a developer changing a single line of business logic.

This use case showcases the automated UI and architecture modernization of a legacy Java application using IBM Bob’s UI Modernization workflow. The source system—a monolithic, server-rendered application built on Apache Struts 2 and running on IBM WebSphere—is transformed into a decoupled, modern two-tier architecture. The modernized system features a lightweight Jakarta EE REST API backend running on Open Liberty and a responsive Single Page Application (SPA) frontend built with React, TypeScript, Vite, and IBM’s Carbon Design System. The entire transformation, including code generation, build error resolution, routing, and end-to-end integration, is executed automatically within IBM Bob.

The Java Unit Test Generation workflow is part of IBM Bob’s Java Premium Package — a suite of AI-driven modernization capabilities purpose-built for enterprise Java applications. This workflow delivers fully automated, production-grade unit test coverage for legacy Java codebases, removing the need for developers to write boilerplate test scaffolding by hand.

Bob analyzes the entire source tree, detects the application’s architecture and design patterns, configures the test infrastructure, formulates a tailored testing strategy, and then generates isolated, runnable unit tests across all application layers — models, repositories, and controllers. Code coverage is measured using JaCoCo, results are committed to a dedicated Git branch, and a visual modernization diagram is produced to summarize the entire operation.

The workflow operates in a structured, multi-phase pipeline: environment analysis → strategy formulation → test candidate selection → batch test generation → coverage analysis → Git commit. Each phase is transparently tracked, making the process auditable and repeatable.

The Java Modernization Lab is a hands-on, end-to-end technical simulation designed to showcase the transformation of monolithic, legacy enterprise Java applications into cloud-native, modern architectures. The lab utilizes IBM Bob—an AI-driven enterprise transformation and software engineering platform—to guide developers through a complete Software Development Life Cycle (SDLC) modernization journey. Specifically, it takes a legacy NetBanking application built on an aging stack and progressively refactors, upgrades, and containerizes it for cloud deployment.

This use case demonstrates how an automated AI assistant named “Bob” modernizes a legacy, dated Java Enterprise Edition (Java EE) application. Specifically, the tool takes an older Taskboard application built with a traditional Java server-side UI framework (like JSF or Struts) and fully migrates it into a modern, decoupled web application featuring a high-performance Java backend and a reactive frontend.

This use case showcases an automated, AI-driven migration of a legacy Enterprise Java (Jakarta EE/Java EE) application utilizing Enterprise JavaBeans (EJBs)—specifically stateless and stateful session beans—into a lightweight, cloud-native Quarkus application. Leveraging IBM Bob (an AI partner for the Software Development Lifecycle) combined with deterministic migration rules, the demo walks through scanning legacy enterprise source code, refactoring the EJB container dependencies, mapping the business logic to contemporary standards (such as CDI, RESTful APIs, and externalized state mechanisms like Redis), and automatically rewriting the application while maintaining absolute functional parity.

The “Using Java with Skills” module demonstrates how to configure and execute enterprise workflows in IBM Bob (an AI-first software engineering IDE) by combining Skills with custom Java logic. While basic Bob skills use Markdown and shell scripts to define playbooks, this advanced use case highlights how developers can write robust, compiled Java classes to act as the specialized execution backend or tooling mechanism for a skill. It showcases a project structure where an AI agent dynamically leverages native Java tools to orchestrate precise codebase manipulations, environment checks, or automated transformations.

This use case outlines the structural presentation-layer transformation of WealthPlan, a secure, multi-role wealth management platform utilized by Business Managers, Wealth Managers, and end-customers. Rather than initiating a high-risk, full-stack rewrite of core financial services, this use case demonstrates an in-place presentation-layer migration. It moves the application from a legacy, server-rendered presentation layer (Java, Spring Boot, JSP, and Bootstrap) to a decoupled, high-performance architecture driven by a modern React frontend and IBM’s enterprise-grade Carbon Design System. To accelerate execution and lower delivery risk, the migration leverages specialized AI-driven software agents (Bob IDE / Carbon Builder skills) and targets a cloud-native deployment on Red Hat OpenShift.

This use case focuses on automating the end-to-end process of upgrading and modernizing Java applications to the latest versions using an AI-driven tool called “Bob.” Bob leverages a systematic three-phase methodology—Analyze, Transform, and Validate—combining static code analysis, automated migration recipes, and agentic subtasks to safely upgrade the source code, build configurations, and framework dependencies.

The use case demonstrates how developers can leverage IBM Bob, an AI assistant, integrated with Grafana using a Model Context Protocol (MCP) server. Instead of navigating separate monitoring and logging dashboards, developers can interact with Bob via natural language within their existing development environment to query application metrics, look up active incidents, fetch logs, and interpret observability data.

This demo showcase how IBM Bob accelerates Instana adoption through intelligent automation and AI assistance. Bob simplifies Instana Server installation, ensuring consistent, standardized deployments with minimal manual effort. End‑to‑end automation enables infrastructure provisioning, application deployment, and Instana Agent setup. Terraform and Ansible scripts are generated automatically, yet remain fully reviewable and customizable. Observability is embedded seamlessly across VMs, Kubernetes clusters, and microservices applications. AI‑driven instrumentation eliminates manual monitoring configuration during development. Instana’s AI‑powered observability enables faster anomaly detection, root‑cause analysis, and resolution. Together, Bob and Instana reduce MTTD and MTTR, accelerate time to market, and improve operational reliability.

IBM Bob is an AI-powered assistant configured as a performance analyst (using a dedicated “performance insights mode”). It acts as a collaborative partner for developers, performance analysts, and application architects by consuming raw observability data (such as latency charts from tools like Instana), architecture diagrams, and workspace source code. The platform automatically processes these multimodal inputs to diagnose system issues, pinpoint precise roots of failures, and model future state optimizations.

This use case demonstrates how an Infrastructure and Operations (I&O) team uses IBM Bob alongside Bob Shell to automate the creation and deployment of Infrastructure as Code (IaC) configuration manifests. In this scenario, an operations engineer uses a localized terminal interface to hand off raw architectural specifications, application layouts, or infrastructure requirements to an intelligent, agentic workflow. IBM Bob ingests these local blueprint documents, reasons through the specified dependencies, and dynamically synthesizes production-ready Ansible Playbooks and Tasks (e.g., configuring an enterprise HTTP web server) right inside the deployment workspace, removing the need for manual script compilation.

The tekton-devops use case demonstrates how IBM Bob (an AI-powered Software Development Lifecycle partner) automates the generation of enterprise-grade CI/CD pipeline manifests. Specifically, this demo showcases how developers or platform engineers can use natural language prompts in tandem with an AI-orchestration framework (via an AGENTS.md context blueprint) to automatically output structurally valid Kubernetes-native Tekton pipelines and task manifests tailored for a specific codebase.

AI Meets Quantum Security: Discovering and Remediating Quantum Vulnerabilities in Enterprise Applications. This use case showcases Quantum Safe coding with IBM Bob, Quantum Safe Explorer and Guradium Crypto Manager.

This use case demonstrates how an AI development assistant named “Bob” can ingest vulnerability reports from dynamic security testing tools—specifically OWASP ZAP—to autonomously analyze, implement, and verify security fixes within a live application environment.

This use case outlines the process of using an AI coding assistant (referred to as “Bob”) to automatically audit, identify, and remediate security vulnerabilities within an open-source Node.js application’s dependencies and source code.

This use case outlines an automated, “secure-by-design” development workflow that integrates AI-driven coding assistants into enterprise software development without compromising security. It demonstrates how an enterprise can orchestrate IBM Bob (an AI coding assistant running in a specialized “Secure Coding” custom mode) to automatically scan repositories, detect vulnerabilities such as hardcoded secrets, and safely remediate them. This entire operational lifecycle is governed by an IBM Model Context Protocol (MCP) Gateway to intercept and authorize tool actions, while utilizing HashiCorp Vault to store and provision just-in-time, least-privilege credentials.

IBM Bob integrates with IBM Concert & Instana through MCP servers for various automation and accelerates tasks for SREs and DevSecOps Engineers. IBM Bob’s custom modes are leveraged to automate SBOM generation for vulnerability management in Concert and for root cause analysis & remediation of incidents in Instana. IBM Concert and Instana integration brings single pane of glass view for runtime observability and vulnerability insights.

Identify, test, and mitigate vulnerabilities in AI agents using adversarial red teaming techniques

An interactive web application that visualizes IBM TRIRIGA location data on an interactive map with advanced filtering and statistics. Part of the IBM UI Modernisation Lab initiative.

Bob is an intelligent automation solution designed to modernize and streamline legacy IBM Maximo customizations. It automatically discovers and analyzes Java-based custom code stored in IBM Cloud Object Storage (COS), eliminating the need for manual assessment. Based on this analysis, Bob generates modular, production-ready Python automation scripts that follow consistent and standardized coding practices. Beyond code generation, Bob accelerates the testing lifecycle by producing comprehensive test assets alongside the scripts. This includes detailed test plans, YAML-based test scenarios, seed data, and API runners, enabling faster validation and deployment. By combining code intelligence with automated testing support, Bob significantly reduces modernization effort, improves code quality, and enhances overall development efficiency.

MREF Contract Manager is a comprehensive Model Context Protocol (MCP) server that enables AI assistants like IBM Bob to manage real estate contracts and leases in IBM Maximo Real Estate and Facilities (TRIRIGA). It provides 10 powerful tools for contract management including creating, updating, filtering, exporting, bulk importing, analyzing statistics, searching, and generating reports—all through OSLC REST APIs. Built with Python 3.10+ and FastMCP framework, it offers production-ready integration with authentication, session management, and comprehensive error handling for seamless real estate contract lifecycle management.

An agentic AI solution for retail that unifies enterprise data, automates customer analytics, and generates personalized marketing recommendations to accelerate customer engagement and business growth.

Diagnostic fraud, such as falsified reports and unnecessary test prescriptions, poses serious risks to patient safety and trust. This solution leverages real-time event streaming with Confluent to continuously ingest lab, referral, and diagnostic data, enabling instant analysis of suspicious patterns. Combined with agentic AI powered by IBM watsonx Orchestrate, it orchestrates fraud detection checks and delivers immediate, actionable insights to patients—helping them make informed, trustworthy healthcare decisions.

Similisense AI is an AI-powered Homeopathy Assistant that augments practitioners with intelligent symptom analysis, repertorization, Materia Medica matching, and prescription recommendations, enabling faster, more consistent, and scalable consultations while keeping the expert in control.

This asset demonstrates an AI‑Powered Test‑Case Generation application built using IBM Bob. It automates the conversion of large and complex technical specifications into structured test cases. The solution eliminates manual interpretation of lengthy documents, reducing errors and effort. Using watsonx.ai, the application applies RAG and vector search for accurate test generation. Test cases and executable scripts are generated in seconds instead of hours or months. Engineers can perform feature‑based testing and manage test cases through a centralized UI. The solution significantly reduces test creation time, MTTD, and QA costs. Overall, it accelerates release cycles while improving test quality and consistency.

See how to use Model Context Protocol (MCP) to interact with IBM Maximo for job plan management.

In the financial services industry, Know Your Customer (KYC) compliance is critical but often time-consuming. The Self-service KYC Agent streamlines customer onboarding by automating identity verification, document validation, and compliance checks.

This demo showcases how IBM Bob accelerates enterprise integration development by using AI to analyze business requirements and automatically generate integration assets.The demonstration starts with a business user describing an integration requirement in natural language — for example, connecting Maximo Enterprise Asset Management with ERP, procurement, OMS, and supplier platforms to automate asset purchasing and fulfillment workflows. IBM Bob analyzes the requirements, understands the integration patterns, and generates the required APIs, connectors, transformation logic, and orchestration workflows. The generated integration services enable seamless communication between enterprise applications while reducing the need for extensive custom coding.The demo highlights how Bob can automatically document integration flows, apply reusable patterns, support testing, and help teams maintain integrations as APIs and business processes evolve. By leveraging IBM Bob, organizations can reduce integration complexity, accelerate modernization initiatives, minimize technical debt, and allow teams to focus more on business outcomes rather than manual integration development.

Use IBM Bob to interact with Sterling Order Management System (OMS) for order management, inventory tracking, shipment monitoring, and analytics.

This solution showcases how IBM Bob analyzes, documents, and modernizes a 20-year-old Java monolithic application. Using natural-language prompts, Bob converts a legacy Struts/JSP application into a modern cloud-native solution consisting of Spring Boot microservices, a React frontend, PostgreSQL database, automated testing, DevSecOps assets, and comprehensive modernization documentation.

Enterprises spend millions on cloud bills and ESG compliance but developers write code completely blind to the carbon and cost impact of every function they ship. Three crises are converging: legacy code silently burning resources in production, AI-generated code shipping new inefficiencies at machine speed, and infra teams stuck resizing around code they can’t touch. EcoCoder is the missing layer bringing carbon and cost visibility directly into the IDE, at the source, before the code ever ships.

This asset transforms raw Excel spreadsheets into interactive dashboards, KPI visualisations, and actionable business insights using IBM Bob. By simply uploading an .xlsx file, users can automatically generate a complete analytics application and leverage IBM watsonx.ai to ask questions in natural language, explore trends, identify anomalies, and uncover data-driven recommendations—without writing code or configuring analytics tools

IBM Bob modernizes IBM i applications by transforming Fixed-Format RPG, Green Screen transformation and data access while preserving business continuity.

Accelerates IBM App Connect Enterprise modernization by intelligently discovering integration assets, identifying technology patterns, assessing migration readiness, and producing AI-driven migration plans with realistic effort estimates. Enables organizations to gain rapid visibility into their integration landscape, prioritize modernization initiatives, and confidently plan their migration to IWHI / Cloud Pak.

This asset leverages IBM Bob, MCP Servers, and live OpenAPI schema discovery to automate the end-to-end software testing lifecycle for IBM Maximo Application Suite. From natural language requirements, the solution automatically generates structured test cases, creates executable Python test scripts, performs intelligent runtime validation, executes tests against live environments, and produces detailed test reports—eliminating manual effort, improving accuracy, and accelerating test cycles

This asset demonstrates an AI-powered approach to accelerating IBM API Connect V5 to V10 migration on CP4I, addressing the single biggest bottleneck in any V5 estate — the manual rewriting of GatewayScript policies flagged as WARN by IBM AMU. IBM AMU scans the V5 API estate, identifies GatewayScript patterns that cannot auto-migrate, and generates a WARN inventory across all APIs. IBM BOB then takes that inventory as its instruction set — converting each unique GatewayScript pattern once into V10 native-gateway code, storing it in a growing pattern library, and propagating the fix automatically across every API that shares the same WARN. The result: four pattern conversions resolve 100% of the WARN inventory, nine APIs are unblocked from a single conversion, and every future CP4I onboarding inherits a proven, tested V10 baseline — compounding migration ROI with every cycle. Built for IBM Integration Solution Architects and CP4I migration teams looking to eliminate manual effort, enforce consistency across API tiers, and scale V5 modernisation at enterprise speed.

AI-powered integration development asset that uses IBM Bob and webMethods Flow Pilot to accelerate Flow Service creation, modernization, testing, documentation, and troubleshooting through natural-language interaction.

By combining IBM Bob, the Model Context Protocol (MCP), and IBM Interact Gateway, existing enterprise REST APIs become AI-ready services that can be securely discovered, understood, and orchestrated by AI assistants. This enables organizations to deliver intelligent, conversational experiences without redesigning or replacing their existing API ecosystem, allowing enterprises to unlock the value of their APIs for the next generation of AI-driven applications.

This use-case describes IBM’s approach to modernizing enterprise legacy Java applications — primarily targeting existing WebSphere Application Server (WAS)/WebLogic/JBoss/Tomcat customers — using the automated scanning, refactoring, and AI-assisted migration tooling in IBM JSphere Suite for Java, together with IBM Bob.

The use case demonstrates how an AI assistant (IBM Bob) can be utilized to automate exploratory testing and subsequent test script generation for a web application (a movie catalog website). By leveraging Model Context Protocol (MCP) servers—specifically the Quarkus MCP server and the Playwright MCP server—the AI navigates a live web browser, discovers UI components, validates a search function, updates the local development environment, writes actual Playwright test scripts, and executes them to verify success.

IBM Bob is an AI coding assistant designed to help developers generate content and write code. This use case focuses on extending and tailoring Bob’s knowledge base to meet the exact constraints and standards of a specific project. Instead of relying solely on the general data it was initially trained on, users can dynamically restrict, guide, and customize Bob’s behavior directly within their project directory using Custom Modes, Model Context Protocol (MCP) servers, and custom validation rules.

This use case demonstrates how a DevOps engineer can leverage an AI-powered assistant called Bobshell to automate the creation of Infrastructure as Code (IaC) and configuration management scripts. Starting from a provided architecture diagram and a list of specific requirements, the tool automatically generates fully structured Terraform and Ansible configurations to quickly move a two-tier web application from the planning phase straight to deployment readiness.

This use case outlines how an enterprise software development team leverages IBM Bob during a software modernization or refactoring project to automatically discover, document, and enforce architectural boundaries within an existing codebase. Rather than manually auditing millions of lines of code, developers use Bob to crawl a complex application directory, analyze package relationships, and automatically generate living design documentation. Crucially, the AI agent translates these discovered patterns into automated Architecture-as-Code test suites (such as ArchUnit tests). These tests are integrated directly into the team’s build pipeline to act as a continuous linting layer, immediately failing the build if a developer accidentally introduces illegal code dependencies or breaks structural layering.

The Bobchestrate Workshop is an intensive, end-to-end practical course designed to teach developers how to build, test, secure, and scale enterprise-grade Agentic AI solutions. Utilizing IBM Bob (the orchestration IDE/agent framework) alongside watsonx Orchestrate, the workshop guides participants from basic “Hello World” agent creation to complex multi-agent architectures. Key areas covered include Model Context Protocol (MCP) servers for backend connectivity, model routing via AI Gateways, guardrails, automated evaluation, red-teaming, and deployment.

This use case outlines how a newly onboarded or existing DevOps engineer leverages IBM Bob to completely accelerate the end-to-end realization of a new web application environment. Instead of spending days manually scripting infrastructure and configuration settings, the engineer provides Bob with raw system requirements and architectural blueprints. Working as an autonomous agent, Bob ingests this context, maps out an immediate execution plan, and auto-synthesizes a fully functional, enterprise-grade Infrastructure as Code (IaC) block containing Terraform files, Ansible Playbooks, runtime automation scripts, and documentation.

This use case outlines how an integration or AI platform engineer leverages IBM Bob as an AI developer partner to accelerate and automate the end-to-end creation, testing, and deployment of custom Model Context Protocol (MCP) tools and AI agents for the IBM watsonx Orchestrate ecosystem. Instead of hand-crafting backend server communication protocols and manually managing command-line configurations, developers use Bob to plan project layouts, write specialized math-calculation MCP servers, execute rigorous automated verification checks, and programmatically package and register these newly minted operational capabilities directly into the enterprise orchestrator using native Command Line Interfaces (CLIs).

This use case demonstrates how an application developer utilizes IBM Bob as an AI security partner to detect, isolate, and remediate hardcoded credentials within an active software project. In this scenario, Bob performs a deep inspection of a Quarkus-based Java REST API codebase, flags an exposed API key, and outlines the associated security risks. Working dynamically with the developer’s local development environment, Bob leverages a dedicated HashiCorp Vault MCP server to mount security engines, securely store the raw credentials, inject required frame dependencies, and rewrite the application properties and source code to inject secrets securely at runtime.

This use case outlines how an enterprise software engineering team utilizes IBM Bob alongside Grounded Tools (Doc MCP) to dynamically index and ingest local, project-specific documentation into the AI agent’s active memory workspace. Rather than relying solely on the static, pre-trained parameters of a standard Large Language Model (LLM), developers use this feature to build a real-time semantic knowledge index of their private repositories, proprietary framework libraries, internal API endpoints, and shifting architecture manuals. By establishing this localized Model Context Protocol (MCP) data pipeline, the team grounds IBM Bob’s generation engine in their own specialized context, allowing the assistant to auto-detect missing baseline knowledge and instantly query the private index for accurate, custom software development and refactoring tasks.

The Legacy-to-MCP use case demonstrates how to extend the utility of legacy or monolithic enterprise applications (such as a Spring Boot Java app or a local on-premises service) by converting their core functional boundaries into Model Context Protocol (MCP) tools using IBM Bob.

Rather than re-architecting the entire application or touching its underlying codebase, IBM Bob reads existing application metadata (such as an OpenAPI specification) and automatically scaffolds a localized, lightweight integration layer (typically using Quarkus or Python). This layer exposes specific, read-only REST endpoints as standard @Tool definitions. The resulting MCP server is then packaged into a containerized sidecar pattern, deploying alongside the legacy application within the same environment (like a Kubernetes pod) to effortlessly integrate old systems into modern AI agentic workflows.

This use case showcases the automation of legacy Java application modernization using an AI-powered assistant named Bob. The scenario walks through replatforming a standard enterprise Java application (e.g., a ModResorts application) into an IBM Liberty environment. By leveraging a structured walkthrough alongside interactive AI capabilities inside an IDE workspace, Bob conducts structural prerequisites validation, parses migration reports (such as from the Application Modernization Accelerator - AMA), executes code-transforming OpenRewrite recipes, diagnoses compilation errors, and resolves nested API dependencies.

The quarkus-ai-integration module demonstrates an enterprise-grade, end-to-end business use case: building and deploying an intelligent, context-aware Virtual Assistant that interacts with transactional business data. In a real-world scenario—such as a banking assistant handling loan applications or an e-commerce bot checking inventory—the application uses Quarkus and LangChain4j to build the user-facing AI chat feature. This assistant doesn’t just generate generic text; it connects to live enterprise databases via Retrieval-Augmented Generation (RAG) and performs actual tasks (like updating a record) using secure Function Calling.

Crucially, the use case also demonstrates how an autonomous AI coding agent (IBM Bob) works behind the scenes alongside the developer. Instead of manually writing complex code to connect the AI assistant to specific databases or security rules, the developer uses IBM Bob to automatically generate the integration logic, wire up the database tools, and test the conversational flows, turning a multi-week development cycle into a structured, assisted session.

See Bob’s SDLC automation capabilities through a realistic scenario: taking an existing codebase and automating the entire development lifecycle from understanding to deployment.

IBM Bob’s Premium Package for Z is a purpose-built AI extension for mainframe developers working in z/OS environments. Unlike generic AI assistants, it provides application-wide context, Z domain expertise, and orchestrated multi-step workflows — directly within the Bob IDE experience. It includes two specialised modes: Z Code mode and Z Architect mode, equipped with deterministic metadata lookups, IBM-curated Z RAG (covering CICS, IMS, JCL), data dictionary management, and a design-first approach that produces intermediate artefacts (spec files, impact reports, data models) before any code is written.