SAP Community - Artificial Intelligence

Asset Management in SAP Cloud ERP 2602

2026-02-04T15:06:17.711000+01:00

Welcome to the blog post for asset management in SAP Cloud ERP 2602 release! This release introduces significant innovations in maintenance management, designed to enhance productivity for maintenance experts, improve safety and compliance protocols, and provide more actionable, centralized data.

Below, you’ll find a curated selection of release highlights from our core product management team. Before diving in, I invite you to watch the release highlights video, featuring a digital version of me! 😀

Table of Contents

New Asset Overview SAP Fiori app (+demo)
Permit to work: new scope item (7Z4) (+demo)
Enhancements to the Manage Maintenance Notification app (+demo)
Further innovations
SAP Asset Performance Management
More information/additional links

New Asset Overview SAP Fiori app

To address the challenge of navigating multiple screens to gather asset information, the 2602 release introduces the Asset Overview app. This SAP Fiori application provides a single, unified interface for maintenance experts to view and interact with the complete hierarchy of their enterprise assets. Access to this application requires EAM - Asset Overview (SAP_EAM_BC_AOVW_MNG_PC) business catalog, which is included in role templates such as Maintenance Planner (SAP_BR_MAINTENANCE_PLANNER), Maintenance Technician (SAP_BR_MAINTENANCE_TECHNICIAN), and Maintenance Supervisor (SAP_BR_MAINTENANCE_SUPERVISOR).

Key features and capabilities:

Unified hierarchy visualization: The app offers a comprehensive top-down and bottom-up view of your asset structure, combining functional locations and the equipment installed within them into a single, traversable tree. Users can expand individual nodes or the entire hierarchy to its lowest level with a single click. A powerful search function allows users to isolate a specific asset and display its complete branch up to the top-level parent.

The new app aims to provide asset-centric data access, focused on:

Flexible column layout: This feature allows a user to select an asset in the hierarchy on the left-hand panel and view its detailed information on the right-hand panel without leaving the main screen.
Master and transactional data: The detail view displays crucial master data, such as manufacturer and model number, alongside visual indicators for warranty status (e.g., color-coded for active, expired or not maintained). It also provides direct access to related transactional data, including open maintenance notifications and orders associated with the asset.

Integrated maintenance actions: The app is not just for viewing data; it enables immediate action. Users can create maintenance notifications directly from the asset detail page through two methods:

Quick create: A simple form requiring a description to generate a notification.
Joule, SAP’s AI Copilot: Users can leverage the integrated digital assistant, Joule, to create a notification using natural language prompts without leaving the app.

Learn more watching the demo below:

Permit to work: new scope item (7Z4)

The 2602 release introduces the Permit to Work functionality under scope item 7Z4. This feature provides a standardized process for issuing permits for high-risk maintenance activities, ensuring work is performed in a safe, secure, and compliant manner. It is particularly critical for industries such as manufacturing, oil and gas, mining, and utilities.

At its core, the Permit to Work process serves as a formal authorization system. It's designed to foster close collaboration between your maintenance, operations, and safety teams, ensuring everyone is aligned on the required precautions to minimize risks.

Initially, this scope item is available for Germany and the US. Availability for other countries will follow in subsequent updates, with a target for all standard countries by the 2702 release.

Prerequisite scope items include Reactive Maintenance (4HH), Proactive Maintenance (4H), Operational and Overhead Maintenance (4BT), and Maintenance Resource Scheduling (4WM).

Core components and configuration

New applications: This functionality is delivered with two new SAP Fiori apps:

Manage Work Permit Template (F4692): Allows for the creation of reusable templates with pre-defined information. This reduces the time required to create new permits and ensures that minimum safety and data standards are consistently met.
Manage Work Permits (F6579): The primary application for creating, processing, and managing the lifecycle of individual work permits. Permits can be created with reference to a maintenance order, an existing permit, or a pre-configured template.

Process overview

1. Initiation: A planner identifies a maintenance activity that requires a permit and initiates its creation, selecting a permit type such as hot work, cold work, or confined space.
2. Approval: The permit is submitted for review. In the initial 2602 release, the permit is automatically set to a "Ready for Issue" status. Flexible workflow capabilities are planned for future releases.
3. Issuance: An authorized user, such as a supervisor, issues the permit to the designated technician.
4. Execution and return: The technician completes the work and returns the permit to the issuer.
5. Closure: The issuer verifies the work site, normalizes the technical object, and formally closes the permit in the system. The system supports actions to "retain and close" or "retain and deactivate" the permit if work needs to be suspended and resumed later.

Learn more watching the demo below by Ebin Joseph, from product management:

Enhancements to the Manage Maintenance Notification app

The Manage Maintenance Notification (F5777) app has been updated with several new features to improve usability and provide deeper insights.

Situation handling: The app now uses situation handling to deliver instant alerts to the maintenance team when a new notification is created or a key status is updated. For example, an alert can be triggered when a notification is automatically generated due to a condition-based maintenance threshold breach, enabling a proactive response.

Advanced filtering: The list report now includes "Asset Location" and "Sort Field" as filter criteria. This allows users to more effectively narrow down the list of notifications to the specific assets or areas for which they are responsible.

Visual charts for measurement documents: For notifications generated from a measurement document threshold breach, the header now includes a chart. This provides a clear visual representation of the measurement readings against their defined thresholds, allowing for quicker analysis.

Reference order tracking: A "Reference Order" field has been added as a filter and a column in the list report. This enables maintenance teams to easily identify and track all notifications that were created as a follow-on work request from a technician in the field.

Conversational AI: Similar to the Asset Overview app, users can now create maintenance notifications directly within this app using natural language conversations with Joule AI Copilot.

Learn more watching the demo below by Syed Kader Abdul Wahab, from product management:

Further innovations

Perform Maintenance Jobs app - Long text formatting: Clarity in work instructions is critical for maintenance technicians. Long text fields for maintenance orders and jobs can now be formatted. This enhancement allows for the use of bolding, bullet points, and other formatting options to structure text, which improves the readability and organization of detailed instructions and notes.

Manage Maintenance Plans app - Deletion of sort fields: To improve data quality and efficiency, the Define Sort Fields for Maintenance Plans configuration activity now includes a delete option. You can now remove outdated or invalid customized sort field values. This ensures that only accurate and relevant sort field values are available in the Maintenance Plan application, improving accuracy in plan management.

Centralized processing of maintenance order workflows in SAP Task Center: Efficiency in approval processes is a key driver of productivity. Maintenance Order workflow attributes are now accessible in SAP Task Center, allowing for centralized processing of approvals. The following attributes are included: Order Description, Order Type, Planner Group, Planning Plant, Basic End Date, Basic Start Date, Priority, and Technical Object. This centralization helps managers and approvers process tasks from a single, unified inbox.

SAP Asset Performance Management

SAP Asset Performance Management integrates with SAP Cloud ERP and empowers asset owners, plant managers, and reliability engineers to optimize maintenance strategies, measure and improve asset performance, and follow through on your sustainability objectives. The 2601 release highlights include bulk activation and deactivation of system elements, more flexible risk and criticality assessment outcomes, CAP-based reliability assessment applications with extensibility, configurable RCM consequence questionnaires, validity periods for assessments, time-window–based rule processing, and embedded analytics dashboards. Read the complete blog post by Kate Dowle: What's New in SAP Asset Performance Management 2601.

If you’d like to stay up to date with the latest APM innovations, follow my colleague Kate Dowle who regularly shares updates and new blog posts on the topic.

More information / additional links

Find all enablement assets and update blog post for Asset Management: SAP S/4HANA Cloud for Asset Management – The Link Collection

Don’t hesitate to leave a comment and check out our community page to ask your questions and engage with the experts. Also, visit the Asset Management community page. Follow the PSCC_Enablement tag to stay up to date with our latest blog posts.

Follow me on LinkedIn and stay up-to-date to our latest enablement assets: Fernanda Rodrigues | LinkedIn

Find all our assets

Do you want to learn more about the main innovations in different lines of business in the SAP Cloud ERP 2602 release? The release 2602 showcases more 130 innovation highlights across the portfolio. Check out our release document for all the details!

Enablement

We at Cloud ERP and SCM Product Success offer a service as versatile as our product itself. Click on the enablement wheel below and check out the numerous offerings our team has created for you:

️ Watch the replays of our SAP Cloud ERP 2602 Early Release Series!

From January 12-16, we hosted a series of 22 expert-led live sessions to highlight the exciting innovations shipped with the SAP Cloud ERP 2602 release. Missed the live sessions? We've got you covered! Take advantage of the entire series or pick and choose the sessions most relevant to you. You will find the recording and presentation for Asset Management as well as 21 other topics of interest. Don't miss this chance and watch them on demand – anywhere, anytime.

Agent-Driven Development: Why Software Engineering Needs a New Mental Model

2026-02-05T07:37:13.359000+01:00

Forget everything you thought you knew about building software. The world of AI agents is exploding, and with it, a fundamental shift in how we develop, debug, and understand our applications. If you're still treating your agents like traditional software, you're already behind!

Let's dive into why your agent development mindset needs a serious upgrade.

The Old Way: Predictable Code
Think about a standard app. If you process a refund, you expect a clear, defined sequence:

Card refunded.
Ledger updated.
User notified.

Every step is hardcoded. If something breaks, you pull up the logs, pinpoint the exact line of code, and fix it. Simple, right? You're in control, the code is the logic.

The Agent Way: Intelligent Decisions (and Mystery!)
Now, imagine an AI agent handling that refund. You've given it tools (like a "refund tool" or a "notify user tool") and a goal. But here's the twist:

The same input can lead to different reasoning paths.
The agent decides which tools to call and when.
The decisions aren't yours anymore, they're the agent's.

Your code becomes the scaffolding -- defining the model, the tools, and the prompt. But the actual "brain" making choices is the AI itself. So, when things go wrong (and they will!), where do you even begin to look?

Why "Debugging" Agents is a Dead End
You're scanning logs, wondering if it "hallucinated" or if the "context window overflowed." The problem? You're trying to debug a dynamic, intelligent system with tools designed for static, predictable code. It's like trying to fix a self-driving car by looking at the engine manual, you need to understand its thought process!

This is where the mind-shift begins.

Enter the Trace: Your Agent's "Thought Diary"
Since we can't see inside an AI model's head, we observe its actions. Every prompt it sends, every tool it calls, every step it takes, and every message it generates leaves a measurable signal.

These signals, combined, reconstruct the complete sequence of actions an agent takes for a single run. This is called a Trace.

What a Trace captures:

The Model's Reasoning: Why did it choose to do what it did?
Tool Calls: Which tools were activated, and with what parameters?
Outputs: What was the result of each step?
Timing & Cost: How long did each step take, and how much did it cost?

Imagine your agent is trying to book a flight. A trace shows you:
"User asked for flights to Paris. Agent decided to use FlightSearchTool with parameters {destination: Paris, date: tomorrow}. FlightSearchTool returned 3 options. Agent then decided to ask user for preferred time."

This is gold! It's your agent's entire thought process laid bare.

Beyond a Single Run: Threads for Conversations
Agents often have complex, multi-turn interactions. When a user chats with your agent, each message generates a new trace. These individual traces are grouped into a Thread, representing the full conversation history. Threads let you see how your agent's behavior evolves across multiple turns, learning and adapting (or failing!) over time.

The big takeaway: When your agent misbehaves, the answer isn't in your Python file, it's in the trace, or it's in the thread!

The New Playbook: Agent Engineering Reimagined
So, how does this "trace-first" approach change everything?

Debugging is now Trace Analysis:
- Old: "Where's the bug in my code?"
- New: "Let's examine the trace to understand why the agent made that decision."
- Example: Your customer support agent gives a wrong answer. Instead of reviewing your Python functions, you pull up the trace and see it incorrectly extracted the customer's ID from a long message before calling the lookupCustomer tool. Aha!
Evals Replace Unit Tests:
- Old: assert output == "expected string"
- New: Your agent's logic lives in its traces. You need to test these traces with evaluations (evals).
- Example: You update your prompt. To ensure it still answers common questions correctly, you run "evals" on a dataset of past traces. An eval might check if the agent correctly used the productRecommendation tool and provided a helpful response, even if the wording changes. You can run these on past data or monitor them live.
Product Analytics Becomes Trace Analytics:
- Old: Track clicks, page views, and conversion funnels.
- New: The same traces you use to debug also reveal rich insights into user behavior, friction points, and failure modes.
- Example: You notice a pattern in your traces: users repeatedly ask for "pricing" but the agent always tries to book a demo first. The trace shows the agent misinterpreted the user's initial intent. This isn't just a bug, it's a product insight showing a user journey friction.

Observability: From "Exhaust" to "Fuel"
In traditional software, observability (logs, metrics) is often seen as "exhaust", passive data you monitor. In the agent world, observability is fuel. Traces power every single workflow that improves your agent: debugging, testing, and understanding user behavior. Your observability platform isn't just for incident response, it's where your entire team collaborates to refine your intelligent agents.

Ready to Shift Your Mindset?
Next time your agent behaves unexpectedly, don't ask to see the logs, ask to see the trace. It's the key to truly understanding, iterating on, and mastering your AI agents.

A.I Assisted Transition at your own Pace: BW7.5 to BDC Pilot Experiences

2026-02-05T12:03:31.021000+01:00

This blog is part of a series related to a complex BW7.5 customer case where we explored together the opportunity to transition to BDC. You can find the intro blog below, plus the links to the subsequent blogs will be listed here -

Link 1
Link 2
Link 3

The Time is Now

At the time of typing this it is still early 2026. The year’s priorities and goals are being set. For many of our BW customers, the end of maintenance deadline set at the end of 2027 for NW 7.5 is looming large. Questions such as the below are being asked –

How can we maintain what we have built over many years without rebuilding from the ground up?
How can we make use of the latest and greatest from A.I?
Can we continue to use our existing skills?
Can we remain compliant to our regulatory requirements?

The goal of this series of blogs is to outline what customers on BW 7.5 can do to modernise their mission critical system of engagement at their own pace whilst embracing A.I, ensuring they avoid expensive regret cost migrations to third party platforms that can often spiral, seldom delivering on the initial promise. These blogs are based on first hand experiences in a pilot project for BW7.5 to BDC.

Interested to learn more? Read on

The Problem Statement

BW 7.5 is the last version of the ABAP stack SAP Business Warehouse that was initially released in the late 1990’s, it delivers out of the box capabilities (business content, extractor logic, authorisation concepts etc) to manage complex third normal form data structures from SAP ECC (legacy SAP application around finance, HR, supply chain etc) across a layered scalable architecture (LSA). In 2016, the ‘new’ BW was released called BW/4HANA with a roadmap to 2040+, triggering a timeline that will culminate in 2027 with the end of mainstream maintenace of the ABAP version BW7.5.

However, many customers for a variety of reasons chose not to move to BW4. Either they have too much logic built in objects not easily ported (for example APDs, BEx) or they were enticed by promises made by best of breed data vendors in cloud native data lake architectures to migrate their BW workload. Often these project spiral in costs and effort without delivering sufficient value.

The Solution

SAP Business Data Cloud (BDC), released in February 2025 is SAP’s fully managed SaaS solution built for modern workloads and to natively handle data-as-a-service from across the SAP Business Suite applications (S/4HANA Public and Private, SuccessFactors, Concur etc). This is achieved at the click of a button whereby ‘Data Products’ are loaded and kept in sync with backend transactional systems, removing the leg work for customers looking to get rapid value from their data. Business Content and Intelligent applications are installed via the BDC Cockpit, surfacing KPIs for decision making across a host of business areas, with a vast amount more to come in 2026. With BDC, SAP Databricks, SAP Snowflake and other best of breed solutions work in tandem with SAP Datasphere on the semantically rich data products providing customers a unified data architecture to deliver next generation A.I use cases.

What adds to the excitement of BW customers setting their new year goals? BDC is the go-to solution for SAP Business Warehouse. BDC provides a strong roadmap for customers to modernise their BW7.5 environment at their own pace, retaining their investments, their skills, keeping their data available and opening their rich sets of historic business data for A.I. This is achieved through the ‘Lift, Shift & Innovate’ approach that allows for large complex BWs to move to a managed cloud service (Private Cloud Edition) of BW within the formation of SAP Business Data Cloud.

The Lift phase moves existing SAP BW systems as-is to SAP-managed cloud infrastructure, extending maintenance timelines (2030 instead of 2027) and reducing operational overhead. The Shift phase exposes SAP BW data as Data Products using the Data Product Generator tool, enabling integration with SAP Datasphere and external data sources while preserving existing use cases. The Innovate phase explores SAP-managed Data Products and Intelligent Applications to replace legacy SAP BW scenarios with modern analytics, AI capabilities, and access to an open partner ecosystem. This phased approach mitigates risk by maintaining existing investments while providing a clear path to cloud-native analytics and reduced Total Cost of Ownership.

There are some prerequisites for your BW system to fulfil prior to embarking on the journey with BDC, the minimum version supporting the data product generator is SPS 24 and it needs to be running on HANA.

Many large global organisations reliant on BW for their strategic reporting, planning/business steering have already begun the transition to BDC to realise the benefits of modernisation to cloud native at their own pace.

‘Vibe Migration’

In Autumn/Winter 2025 the SAP EMEA and Global Solution Advisory teams worked cohesively on a pilot to demonstrate the BW to BDC move for a specific customer case.

This case assessed all aspects of a complex BW7.5 system after the Lift to PCE, demonstrating how the Shift and Innovate phases can look using the modern tools available in SAP BDC with a focus on SAP Datasphere, SAP Analytics Cloud and Artificial Intelligence. Throughout the subsequent blog posts we will share the findings with specifics on how end of life (EoL) objects such as APDs, BEx and other scenarios can be covered either through automated migration to SAP BDC Datasphere, A.I assisted conversion or rebuild.

Please stay tuned for the next in this series of blog posts related to the Data Product Generator.

Enhanced ‘Get Support’ Application: The New System Assistant & More

2026-02-06T11:33:30.473000+01:00

We’re excited to share recent enhancements made to the ‘Get Support’ application in SAP for Me.

The newest update introduces our system assistant, designed to make solving issues faster, and more personalized than ever. It further enhances the Incident Solution Matching recommendations by determining if the SAP Note has already been applied to your system. This reduces the guesswork in determining relevancy and brings us a step closer to a more personalized experience.

System Assistant

What System Assistant brings to you:

Smarter recommendations: By understanding context, it can surface relevant resource, checks, or next steps.
Just the beginning: Additional enhancements to the service are coming soon to further improve recommendation relevancy and to support you in solving your issues faster.

Translation to Improve AI Services:

Non-English case descriptions (Chinese, German, Japanese) will now be automatically translated to English before being processed by our AI services, improving accuracy for predictions and recommendations.

Improved Support Log Assistant:

Additionally, the support log assistant is enhanced. This release introduces improvements when you upload log files during case creation:

The API now supports two new properties: datetime and datetime range. This allows for a more streamlined scanning process and enabling more relevant content recommendations.
File analysis alerts are now displayed inline, positioned between ‘Attachments’ and ‘Contacts’, improving visibility and overall user flow. The analysis report is also automatically attached to the case

Support log assistant

The Top 3 analysis alerts are shown by default, with the option to expand and view up to 5 alerts, ensuring consistency with Incident Solution Matching recommended solutions patterns.

These updates prepare the foundation for deeper AI-driven capabilities coming soon, enabling even more predictive and personalized support experiences.

Other blogs you might be interested in:

Announcing the New SAP for Me Service & Support Dashboard: A Fresh UX for a Better Customer Experience

A Smarter Support Experience

Trust but Verify - Validating SAP Joule Agents with Int4 Suite

2026-02-08T07:49:35.236000+01:00

In my previous posts, I explored why enterprise AI needs a "reality check" through Secret Agent Shoppers and how the role of SAP Functional Consultants is shifting in a world where system configuration is no longer strictly deterministic.

Today, I want to get a bit more practical. How do we actually validate an SAP AI Agent to ensure it’s doing what it says it’s doing? Specifically, we will look at how to automate this validation using Int4 Suite.

Figure 1 - Int4 Suite validating SAP Joule Agent

The Scenario: From Email to Sales Order

Let’s imagine an AI Agent designed to handle Sales Orders. The workflow looks like this:

The Trigger: A customer sends an email requesting to post an order.
The Agent: SAP’s AI Agent receives the mail, interprets the intent, extracts the data, and posts the Sales Order into SAP S/4HANA.
The Completion: The customer receives a notification that their order has been processed.

On the surface, this looks great. But in an enterprise environment, "looks great" isn't enough. We need to validate two specific areas:

Soft Rules: Was the agent’s response professional? Did it include the order number? Was the language correct?
DB Validations: Did the agent actually post the data correctly in S/4HANA? We need to compare the database entries (customer numbers, material indices, quantities) against a reference document to ensure the AI didn't hallucinate or miss a field.

Configuring Validation in Int4 Suite: A 3-Step Guide

Here is how you set up this automated "reality check" within Int4 Suite.

Step 1: Create the Automation Object

First, we create a new automation object. This serves as our "Secret Shopper," simulating the customer by sending the initial email to the SAP AI Agent.

Figure 2 - Int4 Suite Automation Object for sending the email and validating the work of the AI Agent

Step 2: Define Content and "Soft Rules"

Next, we update the object with the email content. This is where we define our "Soft Rules." The beauty of Int4 Suite is that these rules can be written in natural language. There is no coding required to tell the system what a "good" AI response should look like.

Figure 3 - Soft Validation rules within Int4 Suite

Step 3: Set S/4HANA Database Validation

Finally, we configure the DB validation. This is the most critical step. We don't want an AI agent pretending it finished a task when the database tells a different story. We set up ABAP rules to check the newly created order directly inside the S/4HANA database.

Figure 4 - Database validation rules in SAP S/4HANA

The Moment of Truth: Running the Test

When we trigger the validation from Int4 Suite, we get a comprehensive look at the agent's performance.

In our test run, the Soft Rules passed. The AI Agent replied politely and confirmed the order was placed. However, we aren't done yet.

Figure 5 - Soft validation rules correctness

The Final Validation compares the new Sales Order against a "Golden" reference document created with the same input. Only when every field in the S/4HANA database matches the reference exactly can we mark the test as a success.

Figure 6 - SAP S/4HANA Database validation result - comparison with the reference document

Why This Matters

AI models are not static. LLM providers update their models, and "temperature" settings can lead to different outputs for the same input. By using Int4 Suite, you can run these tests daily to ensure that a change in an underlying LLM doesn't silently shift your business processes.

Full Scenario

Video showing how Int4 Suite tests the SAP Joule Agent

Important note:

The aim here is not to question the reliability of SAP AI, but to ensure that changes in the evolving LLM landscape never interfere with the stability and consistency of your production environment.

Joule Is Not a Chatbot: How AI Agents on SAP BTP Help North American Utilities Reduce Risk

2026-02-09T10:02:41.303000+01:00

Joule Is Not a Chatbot: How AI Agents on SAP BTP Help North American Utilities Reduce Risk

Introduction: The Misunderstanding That Holds Utilities Back

Across North America, utilities are under pressure to modernize customer experience while reducing operational risk. When SAP introduced Joule, many utility teams assumed it was “just another chatbot.” It isn’t.

Joule is an AI agent framework that understands business context, triggers governed processes and interacts with SAP systems safely — something a traditional chatbot cannot do.

Utilities don’t need another conversational interface. They need intelligent agents that reduce risk, automate decisions, and protect the clean core.

This is where the SAP BTP AI Foundation becomes the strategic control plane, allowing utilities to innovate without modifying their S/4HANA or IS-U core—preserving a Clean Core while delivering cutting-edge automation.

⭐Why Joule Is More Than a Chatbot

During my learning journey with Joule, one misconception stood out immediately: many people assume Joule is “just another chatbot.” But when you look at how it works on SAP BTP, it becomes clear that Joule is fundamentally different.

A chatbot answers questions. A Joule Agent acts.

Intent Detection: Unlike a chatbot that triggers keywords, Joule identifies a utility consumer's true intent (e.g., a "high bill" might actually be a "meter dispute").
Policy Enforcement: Joule checks SAP BTP Business Rules before any transaction occurs.
Action-Oriented: It initiates the SAP Build Process Automation workflow directly.
Reliable (RAG): Joule leverages Retrieval-Augmented Generation via the SAP HANA Cloud Vector Engine to provide answers grounded in actual utility regulatory manuals, eliminating hallucinations.
Responsible: Every action follows SAP BTP’s security framework, ensuring PII is masked and every interaction is auditable.

In regulated industries like utilities, this shift from conversational assistance to policy-driven automation is significant. It’s not about chatting — it’s about operational discipline.

⭐The Real Problem: Utilities Don’t Need Chatbots — They Need Governance

Most utilities already experimented with chatbots. The results were predictable:

Inconsistent answers
No integration with IS‑U
No audit trail
No process governance
High risk of incorrect customer commitments

A chatbot can talk. An AI agent can act — safely, consistently, and with full traceability.

That difference is everything.

⭐A Reference Architecture Use-Case

A large North American utility was struggling with high operational risk in its customer contact center. Agents were making inconsistent decisions about:

High‑bill disputes
Move‑in/move‑out exceptions
Meter investigation requests
Payment arrangement eligibility

The utility deployed Joule AI agents on SAP BTP, connected to IS‑U through Integration Suite.

Based on scenario modelling and validated utility process patterns, this agent‑orchestrated design is expected to:

reduce manual exceptions by ~35%, and
improve billing accuracy by ~18%. These are directional estimates, not production KPIs.

This is the difference between a chatbot and an AI agent.

⭐Architecture: How AI Agents Actually Work in a Utility Landscape

The architecture relies on the SAP BTP AI Foundation. Joule acts as the orchestration layer, while SAP Integration Suite serves as the governed gateway to the IS-U backend. By utilizing SAP Build Process Automation, we ensure that the AI agent never executes a 'Write' command directly to the ERP; instead, it triggers a governed workflow that includes Human-in-the-Loop approval for high-risk billing adjustments.

⭐How It Works: The 5‑Step AI Agent Flow

1. Intent Identification: Joule receives a request and identifies the underlying business need.

2. Policy Check: The agent checks eligibility and risk flags against business rules.

3. Workflow Trigger: SAP BTP initiates a governed workflow via SAP Build.

4. Human-in-the-Loop Validation: High-value billing exceptions are routed to a supervisor’s 'My Inbox' for final sign-off.

5. Clean Core Integration: Integration Suite updates IS-U (Billing, FICA, or Device Management) via OData APIs, keeping the core clean.

This is what separates a safe enterprise AI agent from a generic chatbot.

⭐Why This Matters for Utilities

Utilities operate in a world where:

Every customer interaction is regulated
Every billing decision must be auditable
Every exception has financial impact
Every process must protect the clean core

AI agents on SAP BTP give utilities:

Governed automation
Consistent decisions
Reduced operational risk
Faster customer resolution
A clean core that stays clean

This is not hype — it’s a practical modernization path.

⭐Key Takeaways

Governed Framework: Joule is an agent, not a chatbot.
SAP BTP is the control center, ensuring safe, auditassssble and compliant actions.
Utilities reduce risk by routing all decisions through workflows and rules.
Integration Suite protects the clean core by using OData/API-led connectivity instead of legacy 'Z' enhancements.
AI agents deliver measurable impact: fewer exceptions, faster resolution, higher accuracy.
Rapid ROI: Leveraging pre-built SAP Discovery Center missions for Joule allows utilities to move from pilot to production in under 90 days.

⭐Conclusion: The Future of Utility Modernization Is Agent‑Driven

Utilities don’t need conversational gimmicks. They need AI agents that understand processes, enforce rules, and reduce risk.

Joule + SAP BTP delivers exactly that.

This is the next evolution of utility modernization — and it’s already happening across North America.

Hands-on Tutorial (SAP) Databricks triggering ML in SAP Datasphere

2026-02-09T10:12:05.656000+01:00

Did you know that SAP Databricks and native Databricks can trigger Machine Learning in SAP Datasphere? Get a Databricks Notebook to call SAP's Predictive Analysis Library. No data needs to be moved around.

SAP Databricks is a Data Science environment within SAP Business Data Cloud. It is primarily intended to access data products from SAP Business Data Cloud for you to build your own custom AI/ML models with its built-in Databricks serverless compute. However, you can also use it to instruct SAP Datasphere to process its data and to create Machine Learning forecasts with SAP HANA Cloud's built-in Machine Learning algorithms. Let's try it out together.

Note that the data and code can be downloaded from this repository:
Hands-on Tutorial (SAP) Databricks triggering ML in SAP Datasphere

Table of contents

Use Case

The use case is inspired by a requirement a logistics customer brought up recently. They keep granular data in SAP Datasphere about the items that shipped in the past. One row of data per shipment, about 80 million records. This data should now be used to create a forecast of how many items are expected in the upcoming days. These estimates will feed into their workforce planning, to have the appropriate number of staff at hand.

Well, for implementing this scenario I have no data from the real world of millions of parcels being processed. The next best data that I could find for this hands-on example is a detailed count of vehicles in Zurich, Switzerland. The city has a number of measurement stations across the town that provide an hourly count of how many vehicles drove by. So instead of predicting the number of expected parcels, we will predict the number of vehicles. The concept is technically the same. The detailed data (3 million records in the Zurich data) needs to be explored, prepared, aggregated and then used as basis for a prediction.

Architecture

Let's keep things simple for this example, and we will create the forecast with a time-series algorithm. The daily count of vehicles that were counted is used to predict how many vehicles (or parcels) are expected in the next few days. The data is stored in a table in SAP Datasphere.

SAP Databricks is used as development environment to script the Python code, that instructs SAP HANA Cloud within SAP Datasphere to create that prediction and to save it to a table in SAP Datasphere. Instead of SAP Databricks you can also follow this tutorial with a native instance of Databricks.

You will see in the steps below, how these instructions are created. But to give you the big picture right away: SAP's Python package hana_ml is used in SAP Databricks to create the SQL syntax that is sent to SAP HANA Cloud to trigger its embedded Predictive Analysis Library.

These links might help to find out more about the Predictive Analysis Library. It contains 100+ different algorithms, all implemented by SAP to make best use of SAP HANA Cloud's architecture.

Course: Developing Regression Models with the Python Machine Learning Client for SAP HANA
Documentation: Python Machine Learning Client for SAP HANA (hana_ml)
Documentation: Predictive Analysis Library

Prerequisites

To follow this tutorial hands-on you need a SAP Business Data Cloud environment with SAP Datasphere and SAP Databricks. Some familiarity with SAP Databricks would help, for instance having gone through this tutorial, which can be implemented with the free trial of SAP Business Data Cloud.

SAP Datasphere Script Server

SAP Datasphere must have the Script Server enabled, so that the Predictive Analysis Library can be used, please see SAP Note 3216010. The Script Server is only available if your system has at least 3 virtual CPUs. Only the very smallest systems are running with 2 vCPUs. If this should apply to your environment, increasing the memory will get you there.

SAP Datasphere Database User

The Python code in SAP Databricks will connect to SAP Datasphere with a Database User. To create this user go in SAP Datasphere to "Space Management", edit your space and in the "Database Users" section create that user. Give it a name and tick the options in the screenshot. These settings ensure that the user can access the data and write predictions to a table.

Click the "info" icon on the right and the credentials show up. You will need

The Database User name (including the name of the space followed by '#')
The Host name
The Port (always 443)
And the password (the password is only shown once. If you lose it, you need to request a new one)

Data upload

To keep things focussed, I have created a CSV file with detailed vehicle counts that you can upload as a single file. In this example, we ignore some important facts that you would need to consider in a real project. For instance the number of measurement stations has been changing over time. We will just take the data as it is, so that we can focus on the end-to-end tutorial without getting lost in the nitty gritty details. After all, the vehicle data is just an example. In reality we should have a clean and full history of all parcels.

Download the historic data and upload the unzipped file in the Data Builder with "Import CSV file".

Deploy the table with the suggested name VEHICLECOUNT. And we have data. Each location might have one or more sensors. For each sensor we have hourly measurements.

Currently the Database User cannot yet access the table though. You just need to put a view on top of the table, which has the option "Expose for Consumption" activated. In the little screencam you see that some records have NULL values for the vehicle count. This is a data quality issue from the raw data provided by the city. The sensors might not have been working at that time. We will ignore that in this tutorial. In the real world you may want to look into this as part of the data preparation, maybe by imputing the missing data..

Demand forecast

All code that is described in this tutorial is part of this repository. Just download and import the DBC archive file into SAP Databricks.

You now have a project called "Logistics forecast", which contains two notebooks:

Store Database User Credentials
Logistics forecast with HANA ML

Store Database User Credentials

Continue by putting your Database User's credentials in a safe place. Instead of hardcoding them into each notebook, store them centrally as Databricks secret. Open the notebook "Store Database User Credentials". Enter your own Database User's credentials in the code and run the cells.

dbuser_address = "yourdbuseraddress"
dbuser_user = "yourdbuser"
dbuser_password = "yourdbuserpassword"

from databricks.sdk import WorkspaceClient
w = WorkspaceClient() 
scope = "sapdatasphere_dbuser"
w.secrets.create_scope(scope)
w.secrets.put_secret(scope,"address",string_value=dbuser_address)
w.secrets.put_secret(scope,"user",string_value=dbuser_user)
w.secrets.put_secret(scope,"password",string_value=dbuser_password)

Each notebook can now retrieve the credentials from that secret. And to the best of my knowledge, SAP Databricks keeps the values so safe, that you cannot even seem them in clear text yourself. You can try to print them for instance, but it will only show "[REDACTED]"

Connection to SAP Datasphere

Now open the notebook "Logistics forecast with HANA ML". All code that we need for the forecasting is already in that file. In the 'Environment'-tab on the right, you see that the Python package hana_ml has been added. Clear the Notebook's output, to be sure that any future output you see, was created by yourself.

Run the first cells to retrieve the Database User credentials from the Databricks secret. Use these to establish a connection to SAP Datasphere.

dbuser_address = dbutils.secrets.get(scope="sapdatasphere_dbuser", key="address")
dbuser_user = dbutils.secrets.get(scope="sapdatasphere_dbuser", key="user")
dbuser_password = dbutils.secrets.get(scope="sapdatasphere_dbuser", key="password")

import hana_ml.dataframe as dataframe
conn = dataframe.ConnectionContext(address=dbuser_address,
                                   port=443, 
                                   user=dbuser_user, 
                                   password=dbuser_password, 
                                  )
conn.connection.isconnected()

The isconnected() function should return "True".

If you are getting an error that the hana_ml package is missing, go back to the 'Environment'-tab and hit "Apply". This will install the package.
If you are getting a Connection failed error "Socket closed by peer", then most likely the Notebook's external IP address hasn't been added yet to SAP Datasphere's allow list. You can see the IP address with this command.

from requests import get
ip = get('https://api.ipify.org').text
print(f'The public IP address is: {ip}')

Then add this address to the allow list as described in the documentation. Currently (February '26) Databricks has a feature in Preview mode to get a static IP address. You can reach out to your Databricks account manager to request having this feature activated in your environment. In case you don't know that person, feel free to ping me and I will try to make a connection.

Data Exploration

Once you are connected, point the hana_ml DataFrame to the Datasphere view you had created earlier. This does not extract any data from SAP Datasphere. The 3 million records remain in place. But you can download rows if you like. Just select 5 rows, to verify the connection does indeed work as expected. Then call a canned report for further data understanding. The details are also calculated within SAP HANA Cloud.

current_schema = conn.get_current_schema().split('#')[0]
data_hdf = conn.table('V_VEHICLECOUNT', schema=current_schema)
data_hdf.head(5).collect()

from hana_ml.visualizers.unified_report import UnifiedReport
UnifiedReport(data_hdf).build().display()

Data Preparation

We would like a daily forecast, but our data is more detailed with hourly timestamps. Hence create a new column that contains only the date, cutting off the hourly information. This column is not persisted, it does not change the underlying view. It is calculating the new column on the fly, when accessing the data.

data_hdf = data_hdf.select('*', ('TO_DATE(MEASUREDATETIME)', 'MEASUREDATE'))
data_hdf.head(5).collect()

Having the MEASUREDATE column make it easy to summarise the measurements by date.

data_hdf = data_hdf.agg([('sum', 'VEHICLECOUNT', 'VEHICLECOUNT')], group_by='MEASUREDATE')
data_hdf = data_hdf.sort_values('MEASUREDATE')
data_hdf.head(5).collect()

All aggregations were done in SAP Datasphere / SAP HANA Cloud. Under the hood the aggregation request was translated by hana_ml into the corresponding SQL syntax, which was sent to SAP HANA Cloud. You can see the SELECT statement that was executed.

data_hdf.select_statement

Plot the daily values. The collect() function downloads the aggregated data as Pandas DataFrame. There seems to be a trend that more vehicles are counted. This could be because of increased traffic, or an increased number of sensors. For this tutorial we won't look any deeper into this. But a weekly pattern seems to be there. A drop over Christmas. And almost no vehicles were counted for a few days in July 2024. That's the data quality issue that was mentioned earlier, the sensors might not have been working. We will ignore that too for this tutorial.

Time series forecasting

Split the data into training and testing. We want a 7-day forecast. Hence put the most recent 7 days aside, to get a feel for the forecasting accuracy.

train_hdf = data_hdf.head(data_hdf.count()-7)
test_hdf = data_hdf.tail(7)

Train a time-series model on the training data. The AdditiveModelForecast algorithm is an implementation of Prophet. For simplicity no hyperparameter tuning is done here.

from hana_ml.algorithms.pal.tsa.additive_model_forecast import AdditiveModelForecast
amf = AdditiveModelForecast()
amf.fit(data=train_hdf, key='MEASUREDATE')

Investigate the model in a canned report.

from hana_ml.visualizers.unified_report import UnifiedReport
UnifiedReport(amf).build().display()

Apply the model on the test data, that was put aside earlier.

predicted_hdf = amf.predict(data=test_hdf)
predicted_hdf.head(5).collect()

Join the true values from the past with the prediction to assess the forecast accuracy.

predicted_hdf = predicted_hdf.set_index('MEASUREDATE').join(test_hdf.set_index('MEASUREDATE'))
predicted_hdf.head(5).collect()

Compare the actuals and prediction in a plot. The forecast is more accurate, than it might appear at first. Note how the y-axis is not starting at zero, but at 1.2 million. Hence the actuals and predictions are quite close.

import pandas as pd
predicted_df = predicted_hdf.collect()
predicted_df["VEHICLECOUNT"] = pd.to_numeric(predicted_df["VEHICLECOUNT"])
fig = px.line(predicted_df, x="MEASUREDATE", y=["VEHICLECOUNT","YHAT"] , title='Vehicle Count Forecast Accuracy test on known past')
fig.show()

Calculate the accuracy of the prediction. A Mean Absolute Percentage Error of 3.3% seems quite all right.

from hana_ml.algorithms.pal.tsa.accuracy_measure import accuracy_measure
metric_names = ['mape', 'rmse']
metrics = accuracy_measure(predicted_hdf.select(['VEHICLECOUNT', 'YHAT']), evaluation_metric=metric_names).collect()
metrics

Databricks contains a very comprehensive Repository where such model metrics (or hyperparameters, images, etc...) can be saved. Here we store just the absolute basics. For a much more advanced approach see this blog "Developing HANA ML models with SAP Databricks" by @nidhi_sawhney.

import mlflow
with mlflow.start_run():
    for index, single_metric in metrics.iterrows():
        mlflow.log_metric(single_metric.STAT_NAME, single_metric.STAT_VALUE)

Now that we have a feeling for how well the model worked on the recent past, train a new model on the full history of the data.

from hana_ml.algorithms.pal.tsa.additive_model_forecast import AdditiveModelForecast
amf = AdditiveModelForecast()
amf.fit(data=data_hdf, key='MEASUREDATE')

Obtain list of the future 7 days that we want to predict. The historic data finishes on 18 January 2026.

futuredatestopredict_hdf = amf.make_future_dataframe(data_hdf, key='MEASUREDATE', periods=7)
futuredatestopredict_hdf.head(10).collect()

Apply the model to predict these future dates.

predictedfuture_hdf = amf.predict(data=futuredatestopredict_hdf, key='MEASUREDATE')
predictedfuture_hdf.head(10).collect()

Turn any potential negative predictions to zero. For this use case negative values would not make sense. Even though this very forecast doesn't have any negative values, you might need this step in your own projects.

predictedfuture_hdf = predictedfuture_hdf.select('MEASUREDATE', ('GREATEST(YHAT, 0)', 'YHAT'),
                                                ('GREATEST(YHAT_LOWER, 0)', 'YHAT_LOWER'),
                                                ('GREATEST(YHAT_UPPER, 0)', 'YHAT_UPPER'))
predictedfuture_hdf.head(10).collect()

You can rename the columns, if you prefer, before writing the forecast to a table.

predictedfuture_hdf = predictedfuture_hdf.rename_columns(['MEASUREDATE', 'VEHICLECOUNT_PRED', 'VEHICLECOUNT_PREDUPPER', 'VEHICLECOUNT_PREDLOWER'])
predictedfuture_hdf.head(10).collect()

And with that, save the predictions as table to SAP Datasphere / SAP HANA Cloud.

predictedfuture_hdf.save("LOGISTICS_FORECAST", force=True)

Using the forecast in SAP Datasphere

The forecast is created and saved to a table. You can now integrate the information into your modelling and share with your users through SAP Analytics Cloud, or any other way you might prefer.

Summary

Now know in detail how SAP Databricks and native Databricks can trigger Machine Learning in SAP Datasphere. It's an option to consider to avoid data movement. SAP HANA Cloud has a long list of built-in algorithms. If there is one specific algorithm you are missing, just get in touch. Maybe it is there under a different name. If it really isn't there, get in touch to check with the Product Group whether it can be implemented.

Happy predicting!

Kick Off 2026 With Impact: Collaborate on 56 Fresh SAP Customer Engagement Initiative Projects

2026-02-09T18:32:10.774000+01:00

We’re excited to announce that Cycle 1 of the SAP Customer Engagement Initiative for 2026 is now live!
This cycle features 56 new projects, offering SAP customers and partners the opportunity to gain early insights into upcoming product developments and collaborate directly with SAP teams to shape the next generation of SAP solutions.

🗓Registration is open until March 13, 2026.

In a rapidly evolving business environment, early involvement can make a meaningful difference. Through the SAP Customer Engagement Initiative, you can work directly with SAP product managers and developers, sharing your feedback on concepts, prototypes, and plans while they are still in the early stages.

To help you explore all available opportunities, we’ve prepared a complete overview of the projects.
View the full list here, or browse the links below to discover the topics most relevant to you.

SAP Ariba

Reporting and Analytics in SAP Ariba Invoicing

SAP Business Technology Platform

SAP Concur

Data & Analytics

SAP S/4HANA Cloud

SAP Globalization

Others

Let’s shape the future together!

Innovation happens through collaboration. By participating in the SAP Customer Engagement Initiative projects, you help SAP create better, more relevant solutions for businesses like yours. This is your chance to influence what comes next.

Don’t miss out – sign up today at influence.sap.com and be a part of the SAP Customer Engagement Initiative Cycle 1 in 2026!

Warm regards,
Your SAP Customer Engagement Initiative Team

Follow-up after registration: When you register for a project, you will be invited to an introductory call with the SAP project lead. At this point further participation is optional. Typically, all activities are governed by the Feedback Agreement with SAP.

Vibe Coding with Joule Studio: Bringing Your Own Model with NVIDIA NIM

2026-02-11T08:34:47.058000+01:00

As we build the future of enterprise AI at SAP, our vision for Joule Studio is clear: to provide a platform where you can build, manage, and scale intelligent agents that are deeply integrated with your business processes. The out-of-the-box capabilities, powered by SAP's native models and the generative AI hub, are designed for robust, reliable, and context-aware orchestration within the SAP ecosystem. But what if you want more control over how your agent thinks, codes, or reasons? What if the model you want isn’t (yet) available in Joule Studio or the generative AI hub? What if you could build it all using natural language?

That’s where Bring Your Own Model (BYOM) meets Vibe Coding in Joule Studio.

The Idea: Build a Joule agent powered by external models.

With this example, you can vibe code a custom Joule agent in Joule Studio that uses a Joule skill to call an external AI model like Nemotron hosted via NVIDIA NIM, one of the most powerful open-access foundation models specifically designed to build high-performance, specialized agentic AI systems.

To be explicit about how this works, it’s a "best of both worlds" approach:

The Agent's Core Reasoning: The Joule agent itself continues to leverage its powerful, default Large Language Models for its primary job: reasoning, planning, and orchestrating the overall workflow. The agent's runtime is optimized to perform best with these native models.
The Skill's Specialized Task: Then, for a specific task — like integrating with Nvidia’s NIM models in this case — the agent uses a Joule skill to leverage the power of NVIDIA Nemotron model. The skill acts as a bridge to specialized intelligence and deep reasoning.

Accelerate Agent development with Vibe Coding in Joule Studio

Vibe coding allows you to transform your ideas into a Joule agents quickly. Here is what you can do with vibe coding in Joule Studio:

Build Joule skills with drag and drop simplicity
Build a Joule agent by prompting in natural language. The agent’s expertise and instructions will be filled automatically with SAP best practices
Enable the tools that the Agent can utilize to generate an optimized response to the user, including the Joule skill with external model, MCP Server or Document Grounding via AI Core.
Test your agent in the private environment
Deploy the agent when ready and share it with colleagues

Vibing Coding in Joule Studio generating Agent's Expertise & Instructions

After the agent is ready, the conversation flow is simple:

The user interacts with the Joule agent in natural language.
Joule asks the user to choose the Nemotron model. Here, I am using: nvidia/llama-3.1-nemotron-nano-8b-v1 and nvidia/nemotron-3-nano-30b-a3b.
A Joule skill sends the user query and the selected model to the NVIDIA Nemotron API.
The selected NIM model processes the request and sends the output to the Joule agent.
The Joule agent evaluates the response, checking how the model solved the required task.
The response is then presented to the user.

The key detail: the user can choose which Nemotron model to use, enabling dynamic querying and true BYOM experience.

Joule Runtime conversation:
"A developer asks Joule to generate a BAPI extension. Nemotron reasons through the logic, generates the code, and explains why it chose that approach."

Joule conversation - User Query, Model Selected & Response from Nemotron.

Model name and response logged in Joule Timeline.

By combining Joule's orchestration with NVIDIA's Nemotron Models, the agent can be scaled to generated responses with deep reasoning, visual contextualization, document analysis and multimodal research.

Example of a Scenario: The Business Problem
"A procurement manager receives hundreds of POs daily. They need to identify risks, anomalies, and optimization opportunities - but it requires analyzing data across multiple SAP systems + deep reasoning."

The Agentic Flow
Agentic Flow leveraging external Models
Some more examples:

Upload images of defective parts/machinery to identify defects and receive recommendations using multimodal AI.
Analyze invoice PDFs to get explanation of charges and identify missing information using Vision Language models
Accurately forecast customer buying capabilities or inventory fulfilling using predictive models.

Why Use External Models Like NVIDIA Nemotron?

Using models outside Joule Studio or generative AI hub unlocks several real-world benefits:

Freedom to bring your own model
Use cutting-edge or domain-specialized models that are not yet natively supported by SAP.
Ship Innovative Agents faster
Experiment with new reasoning, vision, or code-focused models without waiting for platform updates.
Choose the right model
Choose different NIM models for coding, analytics, logistics reasoning, or document understanding.
Future-proof architecture
Your Joule agent becomes model-agnostic, making it easier to swap or upgrade models later.
Enterprise-safe orchestration
Joule Studio still handles identity, governance, and process integrations - only the intelligence is externalized.

Conclusion

You can now build intelligent agents that vibe with your users, adapt on the fly, and leverage state-of-the-art models as of today. Furthermore, your agent can execute at scale to solve more complex problems by empowering them with tools like MCP Server, Document Grounding and Calculators while leveraging the power of external models.

It’s time to build AI agents that unlock the true potential of your business with tools and models of your choice. Here is how you can get started too: Read the blog here.

Creating a ‘Hello World’ Joule Agent

2026-02-11T11:55:37.566000+01:00

Building on Michael Ameling's excellent Agent Builder in Joule Studio announcement and The Joule Studio Learning Series, this post will guide you through building your first Joule Agent.

I'll walk you through the steps to build a "Hello, World" agent. Along the way, you'll get familiar with the basic workflow in SAP Build, explore the UI, avoid at least one common pitfall, and have your agent up and running in just a few minutes. By building the simplest possible agent, you'll gain the confidence that building agents is easy, and creating more sophisticated ones will feel like a natural next step. Let's get started.

Setup and Prerequisites

The setup of SAP Build Apps, the activation of Joule, and the SAP Agent Builder are described in these two blog posts:

I'll assume that's done, and we'll start our journey in the lobby of SAP Build Apps.

Creating a Project

Click on the "Create" button, and select "Joule Skill":

Enter a name and a description:

Creating the Joule Agent

You'll be forwarded to the overview of your project where you can create the Joule Agent:

Again, enter a name and a description. A proposal for the identifier will be generated automatically:

On the details page of your Hello World Agent, you could fill in the fields manually, but let's use Joule to create a proposal. In the top left, click on the Joule icon to open the Joule sidebar. Enter a prompt like this:

"Can you please update our existing Hello World agent by filling in the expertise, instructions and additional context? The agent should respond to every prompt with "Hello, World!"."

As a result, Joule updates the agent, and we're almost done. We just need to add a placeholder tool, for example the calculator, because Joule Studio does not allow an agent to be saved without a tool assignment:

Now you can save the agent, and we can move on to testing the functionality we've just implemented.

Testing the Joule Agent

When you click on the "Test" button (just above the "Save" button), you'll be asked which environment you'd like to test in. Select the environment associated with your email address.

If your email address doesn't appear in the dropdown, you need to activate your private environment first. To do so, click on the SAP Build icon in the top left corner, click on "Control Tower" in the left-hand menu, and then click on the "Environments" tile:

On the Environments screen, click the button to activate your private environment:

Afterwards, you can resume testing and your private environment should appear in the dropdown as described above.

Now we're ready to test the agent, for example with a prompt like "Let's test the agent".

As we can see, the agent correctly responds with "Hello, World!" 😅

To end the test session, just click on the "Stop Testing" button.

Deploying the Joule Agent

To get our agent out of the testing environment, we need to deploy it to a real environment.

Let's create a Hello World environment. Navigate to the Control Tower, select the Environments tile, and click on "Create". Enter a name and description for the environment. The proposal for the identifier will be generated automatically.

Your user will be automatically added to this new environment. If you see a blank screen when you want to view the environment details, just try refreshing the page in the browser. It may take a little while to generate.

Once the environment is active, we can deploy our agent. Click on the "Release" button in the agent overview.

In the subsequent pop-up, enter a release note and click on "Release".

Once released, switch to version 1.0.0 at the top of the screen by clicking on the dropdown next to the title.

In the released version, there is a "Deploy" button instead of the "Test" and "Release" buttons. Click on the "Deploy" button, select the Hello World environment, and click on "Deploy".

After a few moments, the status of agent version 1.0.0 will change to "Deployed and Active".

Testing the Deployment

As a final step in this tutorial, let's test our deployed agent in the Hello World environment.

Open the Hello World environment via the Control Tower and view the environment details by clicking on it in the list. There, you will see the deployment of the Hello World agent we just made.

To test it, open the Joule tab for this environment. Depending on your screen resolution, this may be hidden in the "More" drop-down. On this tab, click the "Launch" button.

Joule will open in a new tab and we can prompt it to test the agent, for example like this: "Run the Hello World agent."

To confirm that Joule actually called the agent, you can investigate the log by clicking on the icon in the top right of the title bar.

Conclusion

Congratulations, you just implemented your first Joule agent! As intended, the overall result is "just" a Hello World agent, but this is an important first step in your journey to becoming a Joule agent builder. You familiarized yourself with the UI and performed the full workflow from start to finish, including creating a project, creating an agent, testing, and deploying it. Along the way, we also used Joule itself to fill in the agent's configuration details.

From here, there are many more topics worth exploring, like Joule skills, MCP integration, or agent-to-agent communication. However, for me, it's always important to build a Hello World example first without getting lost in the details. With more complex starter scenarios, it's easy to get stuck on technical details and lose sight of the big picture. Now that you've completed your "Hello World", you can iteratively add more features and build more sophisticated agents. What's the first use case you're going to tackle?

SAP Joule for Consultants (J4C): A Strategic Overview

2026-02-11T13:56:47.976000+01:00

SAP Joule for Consultants (J4C): A Strategic Overview

SAP Joule represents a significant advancement in SAP’s generative AI strategy, offering a suite of role-based variants including those for end users, developers, and specific line-of-business processes. Among these, Joule for Consultants (J4C) is uniquely engineered for SAP delivery organizations and system integrators. Operating as a standalone capability within SAP Business AI and powered by SAP BTP, J4C is designed to address the historical fragmentation of SAP knowledge by providing a centralized, conversational interface for expert-curated content.

Positioning of Joule for Consultants within the SAP Business AI ecosystem.

Figure 1: Positioning of SAP Joule for Consultants

Core Differentiators and Technical Grounding

Unlike generic AI tools, J4C is trained and grounded in SAP’s authoritative, non-public knowledge assets. This ensures that recommendations remain aligned with "clean core" principles and current product roadmaps.

Exclusive Knowledge Base: J4C utilizes terabytes of gated content, including SAP Notes, Knowledge Base Articles (KBAs), and SAP Activate implementation guides.
Methodological Context: The system natively understands consulting terminology, such as SAP Activate phases and Fit-to-Standard constructs.
Code Intelligence: It leverages a fine-tuned ABAP model trained on millions of lines of code to explain legacy logic and identify dependencies during system conversions.

The J4C reasoning layer integrates diverse SAP data sources to support consultant prompts.

Figure 2: J4C knowledge flow

Strategic Benefits and Implementation Considerations:

Integrating J4C into delivery methodologies offers several measurable advantages, though it requires careful organizational planning.

Key Benefits:

Accelerated Delivery: Reduces the time required to locate authoritative answers during discovery and design.
Risk Mitigation: Grounding responses in SAP best practices minimizes the likelihood of design deviations and subsequent rework.
Scalability: Acts as a continuous enablement layer, allowing junior consultants to access senior-level insights without constant escalation.
Standardization: Ensures a consistent interpretation of SAP guidance across global engagements.

Critical Considerations:

Commercial Readiness: Deployment requires specific SAP AI Unit entitlements and technical BTP configuration.
Accountability: J4C serves as a guide; final design decisions and project governance remain the responsibility of the consultant.
Dynamic Coverage: While extensive, the depth of information may vary by specific solution area and release version.

SAP J4C in action:

Log on to SAP J4C as shown:

Figure 3: Login

Ask relevant query:

Figure 4: Query

The answer as shown:

Figure 4: Response

Grounded in SAP Data:

Figure 5: Guardrails and Grounding

Future Evolution

The roadmap for J4C focuses on transitioning from a conversational assistant to an agentic consulting copilot. This evolution includes automated guidance for SAP Activate deliverables and proactive design validation.

In summary, J4C is an essential tool for the modern SAP consultant, providing a structural advantage in speed, quality, and consistency for complex enterprise transformations.

AI’s Role in Organizational Change Management

2026-02-13T16:32:59.319000+01:00

Let's be honest: most change managers spend more time maintaining spreadsheets than having the conversations that matter or leveraging their empathy and personal skills. AI won't replace OCM—but it can handle the pattern-heavy work, freeing you for strategy, coaching, and navigating organizational dynamics. This post explores how AI augments the six core OCM dimensions in SAP transformations, based on our real project experience.

As part of the OCM Digital Change and Adoption team within SAP’s Consulting Services organization, we lead SAP Organizational Change Management in various SAP transformations. We recognize that Artificial Intelligence (AI) is reshaping also our work —introducing new opportunities and challenges across how we plan, lead, and sustain change. This post explores how AI could influence our Organizational Change Management (OCM) approach in SAP transformations and beyond.

Importantly, these are practitioner perspectives—not product announcements. Our intent is to share how we see the six OCM dimensions evolving, based on our project experience. To keep the focus on opportunities, we deliberately set aside topics such as GDPR[1] and AI ethics here—though they remain essential considerations in practice.

As OCM practitioners, we advise our customers throughout their transformation journeys. Our approach is aligned to the SAP Activate methodology and addresses six core dimensions, underpinned by data-driven solutions.

Below, you’ll find each dimension, how we apply it today, and how AI could augment it. For clarity, we’ve included a graphic of the six OCM dimensions here.

Impact key:

🟩 Medium: Broader acceleration and decision support
🟦 Medium to High: Significant scaling and personalization potential
🟪 High: Step-change in effectiveness and proactivity

🟦 Change Strategy sets direction, aligns stakeholders, and prioritizes the people side of the transformation.
Today: We tailor the change approach to your program context, define scope and outcomes, map stakeholders, and plan governance, milestones, and enablement strategies using SAP good practices.
With AI: We auto‑draft change strategies, stakeholder snapshots, and governance calendars from your business case, project charter, and discovery notes; synthesize interview transcripts into themes and risks; and run scenario comparisons to test plan options. AI also generates first‑cut decks and exec summaries that consultants refine with context.
Impact: Faster strategy and planning cycles, clearer stakeholder alignment early on, and fewer mid‑stream rework loops.

🟩 Change Leadership helps sponsors and managers lead with clarity, consistency, and credibility.

Today: We align leadership on vision and roles, map stakeholders, and equip sponsors with engagement plans, talking points, and routines that sustain momentum.
With AI: We analyze stakeholder networks and sentiment to identify influencers and resistance patterns, recommend an optimal change network for your context, and generate sponsor briefings tailored by audience and region. AI also suggests targeted outreach sequences and tracks follow‑through.
Impact: Faster stakeholder mapping, higher sponsor visibility and touchpoints, earlier detection of at‑risk groups. Which can improve confidence and speed of leadership action.

🟪 Change Communication helps you keep stakeholders informed, engaged, and aligned throughout the transformation.

Today: We craft communication plans, key messages, and stakeholder-specific content based on persona analysis and project milestones.
With AI: We can generate personalized newsletters, FAQs, and leadership talking points in multiple languages and formats, whatever fits the project. E.e. leverage transcripts of AMA Sessions to create a blog in your sharepoint incl a Q&A list. AI analyzes and summarizes sentiment from your employee feedback channels to adjust messaging before resistance escalates.
Impact: Faster and more personalized content creation, higher engagement rates, real-time neutral sentiment tracking.

🟩 Change Realization turns strategy into targeted actions that move people from current to future ways of working.

Today: We assess process, role, and location impacts; prioritize change measures; and coordinate workshops to translate findings into concrete action plans.
With AI: We accelerate impact analysis from design assets and process maps, cluster similar impacts across your units, and auto‑draft tailored action plans and playbooks fitting for your project—reducing reliance on lengthy manual workshops while preserving expert review.
Impact: Faster impact‑to‑action cycle, fewer workshop hours, clearer prioritization across roles and regions. So that the projects change activities translate into visible progress sooner.

🟦 Change Enablement equips teams and end users with the skills and confidence to adopt new solutions and processes.

Today: We design learning strategies, build curricula, and deliver role‑based training, job aids, and hypercare support aligned to milestones.
With AI: We generate role‑specific learning paths, adapt content to proficiency and language, create just‑in‑time guidance, and use usage data to recommend next‑best learning, tailored to your needs, for this you can use SAP’s Learning Needs Analysis (LNA) microapp. AI generates drafts automatic from sources such as Signavio, SAP Best Practices or CALM. In the flow of work, you can combine this with WalkMe Learning Arc (where available) to deliver in‑app, role‑aware walkthroughs and micro‑learning that reinforce new behaviors at the point of need. AI also drafts quizzes, simulations, demos, exercises and scenario‑based practice from source materials and managed via Prompts.
Impact: Faster content creation, easier content updates, higher course completion and satisfaction, reduced time‑to‑competence post go‑live. This can improve the adoption where it matters most in the project.

🟪 Change Effectiveness ensures change activities deliver outcomes and remain sustainable over time.

Today: We define KPIs, collect feedback, run health checks, and apply corrective actions based on adoption, performance, and sentiment trends.
With AI: We combine digital adoption checks, benchmarks, and pattern detection to spot emerging risks, forecast slippage, and recommend targeted interventions before issues escalate. AI evaluates and summarizes your feedback channels and explains variance across different sites or roles in your company.
Impact: Risks identified several weeks earlier before they impact your project value, fewer late‑stage escalations, continuous, fact based adoption insights with numbers.

With these six dimensions, you can transition from the status quo to future-ready ways of working more smoothly —so you can realize the full value of your SAP solutions. AI doesn’t replace the human side of change; it amplifies it. It can free consultants and customers to focus on higher-value activities: judgement, alignment, personalization and leadership.

This post reflects our experience and practitioner view of where AI can deliver value today.Agentic AI might even bring more oppportunities.While we intentionally focus on possibilities here, topics such as GDPR, security, and responsible AI are non‑negotiable in delivery and must be addressed in any implementation.

In our next blog post, we’ll dive deeper into the AI × OCM opportunities from a change manager’s perspective, sharing concrete use cases and practical recommendations.

Let us know what you think—we’d love to hear your perspective and experiences.

[1] GDPR: General Data Protection Regulation (DSGVO in German)

Your Voice Can Shape SAP’s Next AI Innovations: Join the SAP Customer Engagement Initiative Now!

2026-02-13T17:03:04.478000+01:00

Are you ready to unlock the full power of AI and transform the way your business works? With SAP’s latest AI capabilities, you can streamline processes, elevate decision‑making, and accelerate performance across your entire organization.

Now is your moment to move beyond simply adopting AI and become a true innovator. By joining our SAP Customer Engagement Initiative projects, you’ll play an active role in shaping the next wave of intelligent SAP solutions. Your insights won’t just be appreciated - they will directly influence how our AI technologies evolve to meet real business challenges.

Registration is open until March 13, 2026 - don’t miss your opportunity to make an impact.

View the full list here, or browse the links below to discover the exciting opportunities:

SAP Business Technology Platform

AI-powered Code Upgrade Automation

SAP Concur

Intelligent Audit Evolution: Accelerating Audits with Automation and AI

SAP S/4HANA Cloud

SAP Globalization

Others

Let’s shape the future together!

Don’t miss out – sign up today at influence.sap.com and be a part of the SAP Customer Engagement Initiative Cycle 1 in 2026!

Warm regards,
Your SAP Customer Engagement Initiative Team

The Future of SAP ABAP Based Systems with AI: Why MCP Servers Matter

2026-02-15T23:12:32.706000+01:00

What if your AI assistant could actually talk to your SAP system?

Not through screenshots. Not through copy-paste. But real, direct communication where you ask "Help me find and analyze all enhancements related to Sales Process" or "Give me an RCA document for the ABAP dump I saw in production" and get an instant answer pulled straight from your SAP environment.

This isn't science fiction. It's happening now, thanks to Model Context Protocol (MCP) servers.

The Problem We've All Been Ignoring

Let's be honest: for all the hype about AI transforming enterprise software, most of us are still using ChatGPT and Claude like glorified search engines. We describe our SAP problems, get generic advice, then manually dig through transactions to find what we need.

The disconnect is painful. AI assistants are incredibly smart, but they're blind to our actual code. They can't see your complex pricing procedures, can't check your vendor master data, can't analyze your cash flow in real-time.

Until now.

Enter MCP: The Missing Link

To understand why MCP matters, let's take a step back and look at how we've traditionally communicated with SAP systems.

The Evolution of SAP Communication

In the beginning, there was DIAG (Dynamic Information and Action Gateway) the proprietary protocol that allowed SAP GUI to communicate with SAP servers. It worked, but it was closed, SAP specific, and limited to the GUI client. If you wanted to interact with SAP, you needed SAP GUI.

Then came the shift toward modern development tools. SAP introduced the ABAP Development Tools (ADT) framework - the foundation that powers ABAP in Eclipse. ADT brought a crucial innovation: a standardized way for external tools to communicate with SAP systems over HTTP/HTTPS, exposing SAP functionality through REST-like APIs.

ADT framework opened doors:

Eclipse could retrieve code, metadata, and system information
External tools could trigger ABAP unit tests, syntax checks, and activations
Developers got modern IDE features while working with SAP systems

And this is exactly what Vibing Steampunk by Alice Vinogradova leverages.

The MCP server uses the same ADT framework that Eclipse uses to communicate with SAP. It's not reinventing the wheel. it's standing on SAP's own modern integration foundation.

But Here's Where MCP Takes It Further

Model Context Protocol (MCP) is an open standard that lets AI assistants connect directly to external systems. Think of it as a universal translator between AI and enterprise applications.

While ADT framework solved the "how to communicate with SAP" problem, MCP solves the "how to make AI understand and interact with SAP" problem.

Instead of you being the middleman between AI and SAP, the AI can:

Query SAP system metadata through ADT endpoints
Interpret the results in business context
Give you actionable insights in natural language

The combination is powerful: ADT provides the technical connectivity, MCP provides the intelligent interface.

Real Example: Vibing Steampunk MCP Server

I recently discovered (and have been experimenting with) a project called Vibing Steampunk on GitHub. It's an MCP server specifically built for communicating with ABAP-based systems.

But here's where it gets interesting for developers: this isn't just about querying data. It's about how AI can help you build and understand SAP systems.

Scenario: Understanding a BAPI

Before MCP:

You open SE37 → Search for BAPIs → Read documentation → Check parameters → Test in SE37
Time: 20-30 minutes of navigation and documentation reading

With MCP:

You (to AI): "Show me the BAPI parameters for creating outgoing payments and explain the mandatory fields"
AI queries SAP directly → Retrieves BAPI metadata → Explains in context
Time: 30 seconds

Scenario: Code Analysis

Before MCP:

You inherit a custom payment program
You trace through ABAP code → Check database tables → Understand data flow → Document logic
Time: Hours or days depending on complexity

With MCP:

You: "Analyze this payment posting program and explain the data flow from BAPI_XXXXXX to the database tables"
AI queries SAP for BAPI structure → Examines table relationships → Maps the data flow → Explains in plain language
Time: Minutes

Why This Matters for ABAP Developers

1. Faster Onboarding

MCP enabled AI guides new developers through your SAP landscape showing payment BAPI locations, custom table structures, and organizational extensions dramatically reducing the learning curve.

2. Living Documentation

Forget stale documents. AI queries your actual SAP system for real-time information on BAPI signatures, custom table relationships, function module usage, and data element definitions.

3. Intelligent Code Assistance

Beyond GitHub Copilot, AI understands your environment:

"Show payment blocks in REGUH"
"Explain BSEG-payment document relationships"
"Find programs calling BAPI_XXXXXX"

It queries your system for accurate, environment-specific answers.

4. Faster Debugging

Skip manual tracing through BAPI dumps, SLG1 logs, and database states. Ask "Why did payment 12345 fail?" and AI retrieves error logs, checks document structure, and explains the issue.

5. Knowledge Transfer

Preserve senior developer expertise. MCP enabled AI explains custom code rationale, shows configuration context, and guides juniors through complex payment scenarios using real system data.

Important: The AI never executes code directly in SAP it requests information through the MCP server, which enforces all authorization checks and logs every action.

What This Means for the Industry

We're at an inflection point. SAP has announced Joule, their AI copilot. Microsoft has Copilot integrated across Dynamics and Power Platform. Oracle has embedded AI across their cloud suite.

But here's what makes MCP different: it's open and extensible.

You're not locked into one vendor's AI. You can:

Use the AI assistant you prefer (Claude, ChatGPT, local models)
Customize the integration for your specific business processes
Build proprietary MCP servers for competitive advantage
Integrate multiple systems (SAP + Salesforce + your data warehouse)

The Bigger Picture for Development Teams

This isn't just about making development faster. It's about fundamentally changing how we build and maintain SAP systems.

Imagine:

Onboarding: New ABAP developers asking "How does our payment posting process work?" and getting a complete explanation with actual code references and data flows from your system

Code Reviews: AI assistant examining your BAPI wrapper code and saying "This won't work for payment method 'C' because field REGUH-RZALW is mandatory but not populated"

Impact Analysis: Before modifying a payment table structure, asking "What custom programs will be affected by changing table ZPAYMENT_LOG?" and getting a complete dependency map

Documentation: AI automatically generating technical specs by analyzing your actual implementation, not from templates

Troubleshooting: During production issues, asking "Show me all failed payment postings in the last hour with their error messages" and getting analyzed results with suggested fixes

We're moving from "AI that knows ABAP syntax" to "AI that understands YOUR SAP system."

That's not a minor upgrade. That's a paradigm shift in how we develop, maintain, and transfer knowledge in SAP environments.

Your Turn

Have you experimented with connecting AI assistants to your SAP development environment? What repetitive tasks would you want AI to help with? What concerns do you have about AI accessing system metadata?

I'm genuinely curious to hear from the ABAP community. The technology is ready. The question is: what development challenges will we solve with it?

Interested in the technical implementation? Check out the Vibing Steampunk MCP server on GitHub and let me know what you think. Let's build the future of SAP development together.

yaai_cloud - ABAP AI tools Cloud version

2026-02-16T08:04:23.543000+01:00

yaai_cloud - ABAP AI tools Cloud version
Open-Source AI Tools for ABAP Developers

A few months after releasing the ABAP AI tools last year, I started working on a new version, created specifically for ABAP Cloud environments.

I decided to build a cloud version for a couple of reasons. First, for the challenge itself. I had no idea how far I could go in developing these tools, given the restrictions of the SAP BTP ABAP Trial Environment compared to an on‑premise system, where we can essentially do anything we want. Second, not everyone has access to an on‑premise ABAP system to install and experiment with these tools. Since AI tools can introduce security risks, we need to be careful not to expose sensitive data. And finally, this was a great opportunity to build something more complex in a SAP BTP ABAP environment and explore features that only exist in SAP BTP ABAP Environments.

So, let me introduce the ABAP AI tools Cloud version.

This new version comes with many more features and a different approach compared to the on‑premise version. The Cloud version was built with AI agent development as its primary focus, and all the tooling is designed to support ABAP developers in building and testing AI agents.

It also includes a library with a variety of tools for function calling, most of them related to ABAP development tasks and built on top of the XCO Library. These tools allow AI agents to create and maintain DDIC objects, messages, translations, classes, interfaces, and more.

The ABAP AI tools Cloud is organized into four packages:

ABAP AI tools Cloud - https://github.com/christianjianelli/yaai_cloud
ABAP AI tools Cloud Function Calling - https://github.com/christianjianelli/yaai_cloud_fc
ABAP AI tools Cloud REST API - https://github.com/christianjianelli/yaai_cloud_rest
ABAP AI tools Cloud Cockpit - https://github.com/christianjianelli/yaai_cloud_cockpit

The first package contains all the core objects that form the foundation of the ABAP AI tools Cloud.

The other packages provide additional resources and features, such as the function calling library and the Cockpit, which makes it easier to manage settings and test AI agents.

There is also a fifth package, yaai_cloud_examples (https://github.com/christianjianelli/yaai_cloud_examples), which, as the name suggests, contains examples of how to use the tools.

AI Agents Development using ABAP AI tools Cloud

AI agents need at least two fundamental things: guidance and tools.

To guide an AI agent, we provide system instructions that define its role, responsibilities, and how it should use the available tools.

For the agentic part, we need to supply tools that the AI agent can call so it can perform tasks in the system on our behalf.

In ABAP AI tools Cloud, there are basically two ways to develop AI agents.

The first is to manually set everything in the code, the model, its settings, the system instructions, the tools, and so on.

The second way is to configure an AI agent by assigning an LLM model, defining the model settings, configuring the system instructions markdown document, registering the tools available to the agent, and so on.

Let’s look at two coding examples to compare the two development options.

In this first example, everything is defined directly in the code.

CLASS zcl_aaic_example_fc_openai DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_oo_adt_classrun.

  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS ZCL_AAIC_EXAMPLE_FC_OPENAI IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    DATA: l_api_key             TYPE string,
          l_message             TYPE string,
          l_system_instructions TYPE string.

    DATA(lo_aaic_conn) = NEW ycl_aaic_conn( i_api = yif_aaic_const=>c_openai ).

    lo_aaic_conn->set_api_key( i_api_key = l_api_key ).

    DATA(lo_aaic_db) = NEW ycl_aaic_db( i_api = yif_aaic_const=>c_openai ).

    DATA(lo_aaic_openai) = NEW ycl_aaic_openai( i_model = 'gpt-5'
                                                i_o_connection = lo_aaic_conn 
                                                i_o_persistence = lo_aaic_db ).

    l_system_instructions = |# Identity\n|.
    l_system_instructions = |{ l_system_instructions }You are a friendly and helpful math support assistant.\n|.
    l_system_instructions = |{ l_system_instructions }Your primary role is to assist users with mathematical questions and problems.\n|.
    l_system_instructions = |{ l_system_instructions }You must use the provided calculation tools to solve numerical problems, ensuring accuracy.\n|.
    l_system_instructions = |{ l_system_instructions }Never do the calculations yourself. Always use the provided tools instead, respecting the results returned.\n|.
    l_system_instructions = |{ l_system_instructions }Call one tool at a time. You must wait for the result from one tool before making any subsequent tool calls.\n|.
    l_system_instructions = |{ l_system_instructions }Never send multiple tool calls at once.\n|.
    l_system_instructions = |{ l_system_instructions }Always be patient, encouraging, and explain your steps in a clear and understandable way.\n|.

    lo_aaic_openai->set_system_instructions( l_system_instructions ).

    DATA(lo_function_calling) = NEW ycl_aaic_func_call_openai( ).

    lo_function_calling->add_methods( VALUE #( ( class_name = 'zcl_aaic_math_tools'
                                                 method_name = 'add'
                                                 description = 'Use this method to add two numbers (i_num1 + i_num2)' )

                                               ( class_name = 'zcl_aaic_math_tools'
                                                 method_name = 'subtract'
                                                 description = 'Use this method to subtract two numbers (i_num1 - i_num2)' )

                                               ( class_name = 'zcl_aaic_math_tools'
                                                 method_name = 'multiply'
                                                 description = 'Use this method to multiply two numbers (i_num1 * i_num2)' )

                                               ( class_name = 'zcl_aaic_math_tools'
                                                 method_name = 'divide'
                                                 description = 'Use this method to divide two numbers (i_num1 / i_num2)' ) ) ).

    lo_aaic_openai->bind_tools( lo_function_calling ).

    l_message = 'Hi there! What is the result of 5 + 7?'.

    lo_aaic_openai->chat(
      EXPORTING
        i_message    = l_message
      IMPORTING
        e_t_response = DATA(lt_response)
    ).

    out->write( lt_response ).

  ENDMETHOD.

ENDCLASS.

In the second example, we make use of a configured AI agent.

CLASS zcl_aaic_example_openai_agent DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_oo_adt_classrun.

  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS ZCL_AAIC_EXAMPLE_OPENAI_AGENT IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    DATA: l_api_key TYPE string,
          l_message TYPE string.

    DATA(lo_aaic_conn) = NEW ycl_aaic_conn( i_api = yif_aaic_const=>c_openai ).

    lo_aaic_conn->set_api_key( i_api_key = l_api_key ).

    DATA(lo_aaic_db) = NEW ycl_aaic_db( i_api = yif_aaic_const=>c_openai ).

    DATA(lo_agent) = NEW ycl_aaic_agent(
      i_agent_id = CONV #( 'C6111BEC04B71FE0B9DFCCB09425F70E' ) "Replace the agent id with your agent id
      i_chat_id  = lo_aaic_db->m_id
    ).

    DATA(lo_aaic_openai) = NEW ycl_aaic_openai( i_model = 'gpt-5-nano'
                                                i_o_connection = lo_aaic_conn
                                                i_o_persistence = lo_aaic_db
                                                i_o_agent = lo_agent ).

    l_message = 'What data elements does the package yaai_cloud contain?'.

    lo_aaic_openai->chat(
      EXPORTING
        i_message    = l_message
      IMPORTING
        e_t_response = DATA(lt_response)
    ).

    out->write( lt_response ).

  ENDMETHOD.

ENDCLASS.

ABAP AI tools Cloud Cockpit

Configuring an AI agent in ABAP AI tools Cloud involves maintaining a bunch of database tables. To make this whole process easier, the ABAP AI tools Cloud Cockpit was built. It’s a frontend application designed to streamline the development of AI agents created with ABAP AI tools Cloud.

ABAP AI tools Cloud Cockpit Main Features

Configuration

Setup of LLM APIs
Setup of tools for function calling
Setup of documents for RAG (Retrieval Augmented Generation)
Setup of AI agents

Testing and Monitoring

Integrated Chat
Chat Monitoring
System Logs
Background Task Monitoring

Configuring AI Agents

The configuration of AI agents in the Cockpit is a simple process that basically consists of the following steps:

Register the tools (function calling).>
Upload the markdown file containing the system instructions.
Create the agent and assign the system instructions.
Assign the tools you want the AI agent to have access to.
Set the LLM model and its parameters.

In the tools section we register the tools.

In the documents section, we can upload and edit markdown documents.

Once we have the tools registered and the system instructions uploaded, we can proceed with the agent creation and configuration, which is done in the Agents section.

Testing AI Agents

But the ABAP AI tools Cloud Cockpit is really helpful when it comes to testing AI agents. Once we’ve developed all the tools the agent needs, defined the system instructions, and added any extra documentation it may require to accomplish its tasks, we don’t need to jump straight into writing code to test and debug it. Instead, we can use the testing tooling available in the cockpit.

The ABAP AI tools Cloud Cockpit comes with some handy features that make testing and analyzing an AI agent’s execution much easier and much faster.

Integrated Chat

The Cockpit includes an integrated chat on the right side, which we can use to test the AI agent.

Chat Monitoring

In the chat monitoring view, we can see all the messages exchanged with the AI agent, including the tool calls and their corresponding responses.

Another really useful feature is the message sequence diagram, where we can visualize the entire conversation flow, including the tools that were called and the exact order in which they were triggered.

And last but not least, there is the system log, which can be extremely helpful when things go wrong, like communication errors or unexpected behavior.

Built‑in Tools

The ABAP AI Tools Cloud core package yaai_cloud comes with a few built‑in tools that are bundled with the core components because of their importance. Their main goal is simple: keep the context window as small as possible.

Retrieval Augmented Generation (RAG) tools.

Class: ycl_aaic_rag_tools

Methods:

get_list_of_documents
get_documentation

Instead of relying on a vector database to retrieve documents (or chunks of documents), the strategy here is a bit different. The idea is to provide tools that the LLM can use to first fetch a list of all available documentation. From there, the LLM decides which documents it actually needs in order to perform the task it was instructed to execute.

Once it knows what it needs, it can request the specific documents using the corresponding tool. With this approach, we avoid loading unnecessary information into the context window, keeping it as small and focused as possible.

Function‑Calling Related Tools.

Class: ycl_aaic_func_call_tools

Methods:

get_available_tools
request_tools

These tools follow the same philosophy as the RAG tools. The goal is identical: keep the context window as small as possible.

Instead of loading the JSON schema of every available tool into the context window upfront, we let the LLM first retrieve a list of available tools. Then it can request only the ones it actually needs to perform its task. This avoids overloading the context window with information that might never be used and gives the model more control over what it pulls in.

Closing Thoughts

There’s still a lot more to cover about the ABAP AI tools Cloud, but I’ll save that for future blog posts.

The official documentation is available in the GitHub repositories. It’s still a work in progress, but I’m actively updating it and will do my best to complete it as soon as possible.

Thanks for reading, and I hope these tools help you have some fun building AI agents in ABAP Cloud.

ABAP AI tools Cloud is released under the MIT License.

Agentic case resolution – Accelerating AI In Support

2026-02-16T13:00:09.313000+01:00

We are proud to announce the go-live of the agentic case resolution (ACR) minimum viable product (MVP).  A major milestone in our journey to transform how we handle support cases and deliver value to our customers, this launch introduces that streamline repetitive tasks, reduce manual effort, and provide intelligent guidance and automation throughout the case resolution process.

What’s New?

The new agentic platform enables the integration of AI task agents that produce recommendations for new cases, tailored for both customers and engineers. It provides a foundation that supports the incremental expansion of additional agents into the workflow, allowing a modular and flexible approach as the process evolves over time.

For our support engineers this means:

Ready‑to‑review, AI‑generated response drafts for new incoming cases. Engineers can update, refine, and append these drafts with their own insights before sending, maintaining high quality while reducing repetitive work.
Detecting and highlighting potential duplicate cases, helping ensure faster triage and reducing unnecessary customer wait time.
Component change suggestions that support engineers can accurately route cases and accelerate resolution time.

How does it work? 

When a new case is created, the  agentic case resolution triggers a set of AI agents to analyze the case’s initial details to begin troubleshooting. For eligible cases with very high confidence, it can automatically provide a recommended response to customers for newly created Priority 3 (medium) and Priority 4 (low) cases, without direct engineer involvement. Should an engineer be required, it summarizes the initial case description and suggests a recommended response for review, helping customer receive faster, more consistent responses with reduced effort. 

What’s In It for Me?

Customers & Partners 

Consistent, high-quality AI support
Enhanced overall customer experience by leveraging AI solutions to drive efficiency and reduce customer effort
Resolution times significantly reduced through more efficient case workflows for selective Priority 3 (medium) and Priority 4 (low) cases

Our People

Reduces engineer effort
Improved efficiency in case handling workflows
Streamlines tools and processes into one UI to consume AI services more easily
Reduces repetitive tasks
Reduces task switching

SAP

Speeds up case handling processes to reduce resolution times.
Tackles first responses to customers to reduce case backlogs.
Positions the company as an innovator in leveraging cutting-edge technologies.

What’s coming next?  
This technology enables us to continuously add new AI task agents to the workflow in a scalable manner to expand functionality and scope.   In upcoming releases, you’ll see added capabilities like ongoing case response assistance, conversational experience, missing-information and outage detection agents, triage agent including automatic priority change request detector, and more.

The Goal? Effortless, transparent and transformative.

Want to know more?

Experience the next evolution of SAP support with Agentic Case Resolution
Boost your knowledge of SAP Support with Knowledge-Driven AI
Discover the vision - visit the ACR One Slider

Setting the right expectations around AI for code generation and getting past the inherent limits

2026-02-17T11:02:11.670000+01:00

With over two decades of working on AI, starting with my master's thesis on multi-layer perceptrons, I’m excited about the recent innovations in this area, especially as related to code generation. In this blog post, I want to share my perspective on using AI in a very specific context: coding with AI agents based on transformer models, as these are the primary tools we have at our disposal for this purpose today. I’ll start with why I use AI and then share some limitations of AI models and how to get around these pitfalls. Let’s start with a quick definition…

Generative AI is Only One Form of Artificial Intelligence

There's a lot of buzz around Artificial Intelligence (AI) these days, and it feels like every conversation about technology eventually lands on this topic. However, the term "AI" is often automatically conflated with "Generative AI" (GenAI). It's important to make a quick distinction. AI is the broad field of making machines smart. Machine Learning (ML) is a subset of AI that uses data to train models, and Deep Learning (DL) is a further subset of ML using neural networks. GenAI, which creates new content, is the latest evolution that has captured everyone's imagination.

Why I Use AI

AI is Practical

Large Language Models (LLMs) have provided us with an unprecedented natural language interface. This makes them incredibly powerful for tasks like web search and information retrieval, where a human can quickly verify the results. Coding is a domain where outputs are verifiable, which makes AI agents a significant efficiency booster. They aren't here to replace us, but to augment our abilities.

It's crucial to remember that LLMs have zero semantic understanding. They are masters of syntax, predicting the next word (or token) in a sequence through an auto-regressive process. They don't "understand" code; they predict what code should look like.

AI Adds Value to My Work

From my experience, AI brings tangible benefits to my development workflow. Here’s how:

Understanding Codebases: When jumping into a new or complex project, I use AI to get a quick summary of how different parts of the code interact.
Project Planning: Through agent orchestration, AI can help outline project structures, suggest potential components, and map out dependencies.
Code Documentation: This is a huge one. AI is exceptionally good at generating boilerplate documentation, docstrings, and comments, which frees me up to focus on the more complex descriptions.
Enforcing Guidelines: We can use AI to enforce Clean Core principles and other coding guidelines, ensuring that our code remains compliant and release-ready.

My History with AI

My journey with AI didn't start with the recent hype. It goes back to my college days, long before I entered the SAP ecosystem. My master's thesis was on multi-layer perceptrons and scaled conjugate gradient descent methods. Ever since then, I've been independently researching and following the advancements in this fascinating field.

Potential Pitfalls with AI and Take-aways

Differences Between Prompts and Target Language

Natural language is inherently ambiguous, imprecise, and often not concise. Science, and by extension software development, is about making formal, unambiguous statements. The greatest leaps in scientific history, like the formalization of algebra by Leibniz and Newton, came from moving away from rhetorical natural language and towards formal paradigms. The programming languages we use today are a natural evolution of this.

So-called "vibe coding," where one tries to build complex systems using only conversational language, is great for keynotes and simple examples but falls apart for enterprise-grade systems. I've seen attempts to "formalize" prompts to make agents more reliable, but this is a self-defeating exercise. You end up re-inventing a formal programming language, the very thing you were trying to avoid.

Take-away: This is a fundamental problem that won't be solved by simply scaling models. My practical advice is to iteratively update your agent's prompts and instructions as you code. Let the agent update its own instructions when it runs into issues. And most importantly: never commit code without verifying it yourself. Human experience is still an absolute necessity.

Predicting Syntax vs. Understanding Semantics

As mentioned, all modern coding agents are based on a transformer architecture. They predict syntax, token by token, without any semantic intelligence or understanding of programming metaconcepts. They operate on a vast joint probability distribution and can generalize well within that distribution.

However, when faced with an out-of-distribution (OOD) prompt, they "hallucinate." While syntax prediction without semantic understanding is often "good enough" to boost the efficiency of an experienced software engineer, it's irresponsible to leave critical design decisions to these agents without human oversight.

Take-away: Until a new paradigm emerges that gives AI true semantic understanding, human oversight is paramount. Used responsibly, AI is an incredibly rewarding tool that greatly supports our daily work.

Hallucinations (First and Higher Order)

OOD prompts lead to what I call "first-order hallucinations," where the LLM itself can't generalize and essentially makes things up. The answers are unreliable and require verification. Methods to minimize this include training on more data (scaling) or grounding the LLM with symbolic systems like databases or knowledge graphs.

This leads to what I term "higher-order hallucinations." The grounded data source might be perfectly accurate. However, to access it, the agent must translate your natural language prompt into a formal query. If it hallucinates during this translation, it can create an invalid query (getting no data) or a faulty query that retrieves the wrong correct data. The source is clean, but the retrieval is flawed.

Take-away: In the absence of a new paradigm, it's best to use simpler query sequences instead of one complex one. Simplify the toolset available to your agents and bundle related tasks into a single tool to minimize these translation errors.

Non-Determinism in Answers

While the forward-pass of a transformer is deterministic, the token decoding phase is not. This means if you prompt an LLM five times, you might get five different answers. For coding, this is problematic. Even with the temperature parameter set to zero, non-determinism persists.

Take-away: You never know if you've received the "best" possible generated code, and neither does the AI. This makes human verification absolutely critical, always. For mass refactoring, a robust review process is essential. Interestingly, review agents can help here, but the final decision must rest with a human.

Explainability & Verifiability

LLMs are notoriously black boxes. Billions of floating-point numbers don't offer a semantic explanation for why a particular answer was generated. Research into making these models more transparent is still in its infancy. The lack of semantic understanding, paired with non-determinism, makes true explainability incredibly difficult.

Take-away: For now, the only option for users is to wait for new research and paradigms to emerge.

TL;DR

Human oversight is critical until AI gains a true semantic understanding, which it currently lacks.
Use generative AI to speed your coding, but…
Never commit code without verifying it yourself.
Use simpler query sequences instead of one complex one.
Have a robust code-review process with humans making the final decision.

Next Steps

It is irresponsible for any serious software engineer to ignore the current suite of AI tools, despite their shortcomings. Demonizing them is counter-productive. For those who know what they're doing, these tools are massive efficiency boosters. With responsible use and human oversight, they can be successfully integrated into enterprise workflows and offer many opportunities to improve the human-machine interface.

Outlook

We should not believe all the hype or inflate our expectations of what AI can realistically do today. At the same time, we shouldn't refrain from engaging with these tools in a meaningful way. We, the developers, are still the ones with the creativity, innovation, and semantic understanding. Let's use these tools to amplify that.

Happy coding!

What are your thoughts? Share your experiences with AI in the comments below!

Webinar Announcement: AI-Powered Resume Assessment - The Future of Workforce Screening

2026-02-19T13:30:00.018000+01:00

In today's competitive talent landscape, the difference between finding exceptional candidates and settling for mediocre ones often comes down to one critical factor: how effectively you can screen and assess resumes at scale. Traditional manual resume review processes are not only time-consuming and inconsistent, but they also introduce unconscious bias and often miss qualified candidates buried in high-volume applicant pools. The solution? AI-powered resume assessment—a transformative capability that's revolutionizing how organizations identify, evaluate, and prioritize top talent through intelligent, unbiased screening processes.

We're excited to introduce our upcoming lab session, AI-Powered Resume Assessment: Why It's a Must-Have for Every Program - a comprehensive, practical workshop designed for SAP Fieldglass users ready to modernize their screening processes and unlock measurable efficiency gains. Whether you're exploring AI adoption for the first time or looking to optimize your existing workforce management workflows, this session provides the complete A-to-Z walkthrough you need to implement AI-powered resume assessment with confidence and immediate impact.

Why You Should Attend

1. Expert-Led Implementation Guidance

Learn from seasoned SAP Fieldglass specialists who have successfully deployed AI-powered resume assessment across diverse industries and program types. Gain access to proven configuration strategies, implementation best practices, and insider tips that can accelerate your deployment timeline while avoiding common pitfalls that slow down adoption.

2. Measurable Efficiency and Quality Gains

Discover how AI-driven scoring brings consistency and fairness to your candidate evaluation process, eliminating format variations and subjective inconsistencies that plague manual review. Understand the tangible impact on screening speed, quality improvements, and bias reduction that organizations are achieving, with real metrics and benchmarks you can apply to your own program.

What's on the Agenda

Introduction to AI-Powered Resume Assessment in SAP Fieldglass
Complete Configuration Walkthrough: From Setup to Go-Live
Measuring Success: KPIs, Metrics, and ROI Demonstration
Real-World Case Studies: Efficiency Gains and Quality Improvements
Interactive Q&A Session with Implementation Experts

Who Should Attend

This lab is ideal for talent acquisition leaders, procurement managers responsible for external workforce programs, SAP Fieldglass administrators, and HR technology specialists. It's particularly valuable for organizations with high-volume staffing needs, multiple supplier relationships, or teams seeking to reduce manual screening overhead while improving candidate quality and consistency.

1. Organizations Beginning Their AI Journey

Teams exploring AI capabilities but uncertain about implementation complexity will discover a low-risk, high-impact entry point. Learn how to adopt AI-powered resume assessment with minimal technical overhead while achieving immediate efficiency improvements that demonstrate clear ROI.

2. High-Volume or Multi-Supplier Programs

Organizations managing large numbers of suppliers or multiple MSPs will see how AI-driven scoring creates consistency across varied resume formats and submission quality. Eliminate the inefficiencies of manual review while ensuring fair, unbiased evaluation of all candidates regardless of source.

3. Fast-Growing External Workforce Programs

Programs dealing with increasing requisition volume, time-sensitive staffing needs, or resource constraints will discover how AI assessment reduces manual review time while improving screening accuracy. Transform bottlenecks into competitive advantages through intelligent automation.

How to Register?

Secure your spot in this essential hands-on lab session by registering at the link below. This interactive workshop is designed to provide immediate, actionable value that you can implement right away.

Registration Link: https://event.on24.com/wcc/r/5234455/09D6931769E691DAE81020D168F92A74

Event Details

Date: March 18, 2026
Time: 10 AM ET / 2 PM GMT / 3 PM CET / 6 PM GST
Format: Interactive hands-on lab with live Q&A
Recording: Available on-demand following the live session
Note: APAC-friendly replay session planned for April

Investment in Future

In an era where talent acquisition speed and quality directly impact business outcomes, AI-powered resume assessment isn't just a nice-to-have feature—it's a strategic necessity. This lab session represents an investment in your organization's competitive advantage, providing the knowledge and tools needed to transform your screening processes and deliver measurable value to stakeholders.

Call to Action

Don't let manual screening processes limit your program's potential. Join us for this comprehensive lab session and discover how AI-powered resume assessment can revolutionize your talent identification process. With hands-on guidance, proven best practices, and immediate implementation support, you'll leave this session ready to drive measurable improvements in efficiency, quality, and candidate experience. Register today and take the first step toward modernizing your workforce management approach.

GRC, Trade and Tax in SAP Cloud ERP 2602

2026-02-19T14:07:53.164000+01:00

Hello Experts,

I'm excited to share the update regarding our latest release - GRC, Trade and Tax in SAP Cloud ERP 2602. This update highlights many significant innovations from SAP Risk and Assurance Management, SAP Watch List Screening, SAP Document and Reporting Compliance, as well as SAP Cloud Identity Access Governance.

For a quick overview of the top release highlights for GRC with 2602, you can watch the video below.

Video 1. Release Highlight Video for GRC, Trade and Tax in SAP Cloud ERP 2602

This blog covers the following innovations:

SAP Document and Reporting Compliance

AI-assisted trend analysis and summary for reports (beta)
Embedded analytics to facilitate VAT adjustments
E- verify and Automated Handling of Draft VAT Returns from Authorities
Enabling Electronic Invoices Through KSeF 2.0 for Poland

SAP Risk and Assurance Management

Extended analytical and reporting capabilities: new reporting dashboards with SAP Analytics Cloud, enterprise edition

SAP Enterprise Threat Detection

Intelligent alert handling and investigation recommendations
Management-focused monitoring dashboard

SAP International Trade

Export declaration for plants abroad in the context of Registration for Indirect Taxation Abroad (RITA)

SAP Watchlist Screening

Delta Screening

SAP Document and Reporting Compliance

AI-assisted trend analysis and report summary

Tax accountants often spend significant time validating data by comparing current tax figures with previous returns. To accelerate this process, we introduce AI-assisted trend analysis for VAT returns. This feature helps tax experts by automatically uncovering hidden trends, flagging outliers, and detecting root causes for discrepancies. It provides intelligent summaries that can be used to simplify the approval process and support future audits. This innovation allows the team to move from reactive validation to proactive analysis.

Picture 1. AI-assisted trend analysis and report summary

Value Proposition

Reduce the time needed to interpret VAT data across periods, leading to faster reviews, quicker approvals, and shorter reporting cycles.
Accuracy is improved and compliance risk is reduced. This helps identify anomalies early, minimizing manual errors and lowering the risk of incorrect filings.
Easy to make clear and informative data-driven decisions.

Capabilities

The analysis highlights key trends, fluctuations, and irregularities, and flags values that help to identify potential errors or compliance risks.
Provide concise summary of key VAT insights to support faster reviews, approvals, and decision-making.

Embedded analytics to facilitate VAT adjustments

During the preparation of statutory reports, tax experts require deep visibility into their data to ensure accuracy. With the 2602 release, the 'Manage Tax Items' activity within SAP Document and Reporting Compliance is enhanced with a powerful ''analyze data" option.

This provides tax experts with additional fields and the flexibility to analyze tax data to identify anomalies. Now you can easily see how invoices are mapped to your VAT returns and pinpoint any documents that might have been excluded, enabling seamless adjustments integrated directly with accounting. To further tailor the solution, you can now use extensibility to plug in your own custom analytics CDS views, allowing you to choose between standard SAP-delivered queries or your own defined views for analysis.

Video 2. Embedded analytics to facilitate VAT adjustments

Value Proposition

Advances the VAT review and adjustment by integrating analytics.
Improves accuracy and strengthens compliance through data-driven decisions.
Reduces manual effort and reliance on offline analysis and external tools.
Enhances analytical transparency and enables faster and more confident decision-making.

Capabilities

Embedded analytics within the Manage Tax Items for Legal Reporting application
Direct access to detailed VAT tax line-item records with added data points
Interactive analytical views with charts, filters, and drill-down capabilities
Trend analysis and comparisons across multiple VAT dimensions
Identification of documents for inclusion in or exclusion from VAT returns
Analysis at the point of action without switching applications
Support for efficient VAT reconciliation and compliance preparation

For more information, see: Manage Tax Items for Legal Reporting | SAP Help Portal

E- verify and Automated Handling of Draft VAT Returns from Authorities

A growing number of tax authorities are providing pre-populated, or draft, tax returns based on real-time transactional data. Our latest update helps you automate the handling of these draft returns, ensuring consistency with your company's books. With this feature, you can pull auto-populated returns from an authority's portal and automatically compare them with the returns prepared in your ERP system to identify any mismatches.

Based on the reconciliation results, you can then process actions such as submitting a delta file, accepting, or rejecting the draft. This streamlines the entire process, from review and correction to the submission of the final return.

Video 3. E- verify and Automated Handling of Draft VAT Returns from Authorities

Enabling electronic invoices through KSeF 2.0 for Poland

With the Polish Ministry of Finance enforcing the use of electronic invoices through the KSeF 2.0 platform beginning in February 2026, we are equipping you to meet this mandate head-on. SAP Document and Reporting Compliance now enables you to generate B2B e-invoices in the required XML format from both Finance (FI) and Sales & Distribution (SD), including tax invoices, correction invoices, down-payment invoices, and self-billing invoices. You can submit these invoices interactively to KSeF 2.0, visualize them in a human-readable PDF format with a QR code, and retrieve supplier invoices for automated posting.

Picture 2. Enabling electronic invoices through KSeF 2.0 for Poland

SAP Risk and Assurance Management

Extended analytical and reporting capabilities: new reporting dashboards with SAP Analytics Cloud, enterprise edition

We are introducing the new Risk and Compliance Cockpit, an SAP Analytics Cloud story that gives you an instant, comprehensive overview of your organization's compliance landscape.

This dashboard empowers compliance managers to identify process inefficiencies by visualizing compliance issues organized by type and status, with charts showing trends over time. It makes it easy to compare current performance against historical data, highlight long-term trends, and identify deviations. With insights into average issue resolution times and year-to-year analysis, this single source of truth helps you prioritize critical unresolved issues and improve operational efficiency.

Video 4. Extended analytical and reporting capabilities: new reporting dashboards with SAP Analytics Cloud, enterprise edition

Value Proposition

Get an instant overview of compliance issues, organized by type and status
Improved operational efficiency supported by trend and year-to-year analysis
Charts visualize trends over time
Overview of what to prioritize by highlighting critical unresolved issues

Capabilities

Identify inefficiencies in organizations' processes
Instant overview of compliance issues
Filter business data to examine specific categories of compliance issues
Visual and comparative analysis of data
Compare current performance while highlighting long-term trends and deviations

For more information, see: Risk and Compliance Cockpit

SAP Enterprise Threat Detection

Intelligent alert handling and investigation recommendations

In SAP Enterprise Threat Detection, cloud edition, investigations are the central hub for examining security incidents. This new capability automates and enhances this critical process.

The primary value of this feature is to decrease the manual effort required by SAP monitoring agents and increase their overall efficiency. When an agent prepares an investigation to send to a customer, they are now supported with automatic, case-specific response and mitigation recommendations.

This helps teams by automatically compiling investigation results and formulating suggestions for customers on how to address the alerts. The system intelligently generates these recommendations based on the standard operating procedure of the specific pattern that created the alert, further enhanced by predefined value lists and machine learning functionality. This ensures that the advice provided is both highly relevant and immediately actionable, allowing your security teams to move from detection to resolution faster and more effectively.

Picture 3. Intelligent alert handling and investigation recommendations

For more information, see: Generating Investigation Recommendations

Management-focused monitoring dashboard

We are introducing a powerful new monitoring dashboard within SAP Enterprise Threat Detection, cloud edition, specifically designed for management roles. In today's complex security landscape, having a clear, high-level view of your organization's cyberhealth is not just an advantage; it is a necessity. This new dashboard is for all managers and security leaders who need to quickly understand current security events, alerts, and ongoing investigations to make informed, timely decisions.

It facilitates a deeper understanding of complex security data by offering a comprehensive picture of your system's cyberhealth and protection status. The dashboard also shows the distribution of security events by various criteria, effectively highlighting the most affected systems, patterns, and users to help you focus resources where they are needed most.

To ensure the information is tailored to your specific needs, you can also create your own personalized monitoring pages with a selection of charts that are most relevant to your responsibilities..

Picture 4. Management-focused monitoring dashboard

For more information, see: Using the Monitoring Dashboard

SAP International Trade

Export declaration for plants abroad in the context of Registration for Indirect Taxation Abroad (RITA)

For businesses operating with plants abroad, ensuring the correct export declaration is crucial. In a plant abroad scenario, this feature ensures that the country of the delivering plant, rather than the country of the company code, determines the correct foreign trade organization for the customs declaration. This enhancement improves compliance with international trade regulations for businesses leveraging the "Registration for Indirect Taxation Abroad" (RITA) scope.

Value Proposition

Enhance compliance with trade regulations by ensuring the correct foreign trade organization is used for export declarations.

Capabilities

Manage your export declaration in SAP Global Trade Services using the foreign trade organization within the country of the plant abroad.
Identify plants abroad on pro forma invoice line items by considering countries where registration for indirect taxation (RITA) is enabled.

In SAP Cloud ERP, a billing document exists where goods delivery is performed via a foreign plant, for example, the plant country is different from the country of the company code.

Picture 5. Export declaration for plants abroad in the context of Registration for Indirect Taxation Abroad (RITA)

In SAP GTS, Edition for SAP HANA, the FTO of the corresponding export declaration is now determined based on the legal unit corresponding to the foreign plant used in the billing document.

Picture 6. Export declaration for plants abroad in the context of Registration for Indirect Taxation Abroad (RITA)

For more information, see: Enablement of Plants-Abroad for Export Processing and Foreign Plant

Delta screening with SAP Watch List Screening and manual release of blocked document items

Continuous compliance with sanction party lists is critical. Screening requests sent to SAP Watch List Screening will now remain active for delta screening for up to one month. This means the system automatically performs delta screenings against any changes to watch lists and updates the status of your business partners and documents accordingly, providing automatic coverage without requiring new manual screenings.

Additionally, for situations requiring manual intervention, the "Manage Documents - Trade Compliance" Fiori app now allows authorized users to manually release a trade compliance document item that is blocked. This creates a simple, straightforward, and auditable overrule process to comply with legal requirements while ensuring business continuity.

Picture 7. Delta screening with SAP Watch List Screening and manual release of blocked document items

For more information, see: Integration with SAP Watch List Screening and Delta Screening in SAP Watch List Screening

Watch the replays of our SAP Cloud ERP 2602 Early Release Series!

From January 12-16, we hosted a series of 22 expert-led live sessions to highlight the exciting innovations shipped with the SAP Cloud ERP 2602 release. Missed the live sessions? We've got you covered! Take advantage of the entire series or pick and choose the sessions most relevant to you. You will find the recording and presentation for Artificial Intelligence as well as 21 other topics of interest. Don't miss this chance and watch them on demand–anywhere, anytime.

Find all our assets

We at Cloud ERP and SCM Product Success offer a service as versatile as our product itself. Check out the numerous offerings our team has created for you below:

Don’t hesitate to leave a comment and check out our community page to ask your questions and engage with the experts. Follow the PSCC_Enablement tag to stay up to date with our latest blog posts.

Using AI Agent Cline to Remove Deprecated Code from SAP Fiori Applications

2026-02-21T17:10:44.622000+01:00

Using AI Agent Cline to Remove Deprecated Code from SAP Fiori Applications

Introduction

SAP Fiori applications are built on the robust foundation of UI5 libraries, which are updated each quarter to deliver new features and controls. Traditionally, these libraries have evolved with a strong emphasis on backward compatibility, where addressing deprecated code was encouraged but not strictly enforced.

However, with the imminent Fiori UI5 2.0 release, all deprecated elements will be removed, making the elimination of deprecated controls not just a recommendation, but a clear guideline.

In addition, maintaining clean and up-to-date code is crucial for enhancibility, performance, security, and compatibility. Deprecated APIs, outdated libraries, and legacy patterns can lead to technical debt and potential issues in future upgrades.

In this blog, we’ll explore how AI Agent Cline can help identify and remove deprecated code from Fiori applications efficiently.

1. Configuring Cline for Fiori Applications

Before using Cline, ensure it is properly configured to analyse SAPUI5/Fiori applications.

Prerequisites

GitHub Copilot license
Visual Studio Code
Installation of GitHub Copilot extension in Visual Studio Code

Installation of Cline extension in Visual Studio Code

Click on Extension icon (Ctrl+Shift+X)
Search for cline
Click on install
Open Cline by clicking on the Cline icon in the vertical icon toolbar in VS code.

The Cline welcome screen is shown.

Click on Settings icon in the top right corner

Select GitHub Copilot as the API Provider and copilot -claude-sonnet-4.5 as Language Model and press “Done”.

Installation of the MCP server for SAP Fiori

In the cline panel, click on the MCP Servers icon on the top-right corner.

Click on Configure
Click on Configure MCP Servers.
The file cline_mcp_settings.json opens. Maintain UI5 MCP server as shown below and click on Done.

Note: (@ui5/mcp-server) is a SAP published UI5 MCP server. It allows AI assistants to write SAPUI5 code. SAP currently prevents the usage of MCP servers together with GitHub Copilot. Hence, Cline is being used as an alternative. However a GitHub Copilot license is required for accessing SAP’s approved AI models. UI5 MCP server supports UI5 Linter along with other tools. Linter in particular is useful in identifying deprecated code from the applications and for working on subsequent fixes.

Now that we have configured VS code with all the required tools, we can proceed with fixing the deprecated code issues.

2. Prompting Cline to Evaluate Deprecated Code

After trying multiple approaches to prompt Cline to evaluate and fix deprecated code following steps proved to give consistent results. This approach is equally effective for free style applications as well as Fiori element based applications.

Tips:

Following example is an approach which worked for my use case. There were apps with ~800 issues. So going slow initially helped me gain confidence in the solution provided by AI. There by reducing subsequent effort in error fixing.
In Cline, describe the task as precisely as possible.
Clone the repository to your workspace
Mention the relevant project in task prompt, if you have multiple repos in your workspace.
Mention that the available MCP servers should be used.
Working context is set in the first prompt and then tasks are executed under it. If a new task is started, then the context is to be set again.
Cline would ask for your approval for using MCP server, for executing certain commands. Auto approval can be configured in MCP configuration.
File changes by Cline can be reviewed in Git Lens view of VS code.
If automation test scripts with good coverage is available in the repository, a better approach will be to fix the deprecated code in test scripts first. These scripts can then be regularly executed by cline to validate changes.

Example:

Prompt 1: Setting “Working context”

Cline was asked to find and evaluate deprecated code issues (both error and warning) in the application using linter command. Working context is set for Cline to follow SAP UI5 guidelines only and use the configured UI5 MCP server. This context helps Cline to stay within the SAPUI5 guidelines while solving the issues going forward.

Cline would eventually categorize the issues and prepare a roadmap for fixing the same.

In cases with large number of identified issued, which might span over days to fix, Cline might prepare a .md file with following type of details for future reference.v

Categorisation of the issues into Low Medium and High
Issue detail with suggested solution
Number of files affected with same issue
Effort breakup to fix the issues

Testing strategy to mitigate subsequent breakdowns
Resource required

Risk Assessment

Prompt 2: Start Fixing the Issues

For start we picked 1 type of issue, and fixed it in all files. Maybe start with a low or medium category. Such issues require less effort, get fixed quickly with negligible breakdown in the application. The number of issues start reducing at a fast pace.

We asked Cline to suggest which issue to start with. It evaluated the list of issues to prepare a suggestion. Developer can choose the fixing strategy and include it in the prompt for Cline to suggest accordingly.

We started with a low priority issue as per suggestion shared by Cline.

For first few files, Cline asked developer to validate the changes before saving. Cline can be instructed to save the file directly.

Once some issues are fixed and tested, you can instruct cline to replicate the fix in other files without approval. Change log can then be viewed in Git Lens.

A summary get generated by Cline for developer to check how far they have come along with the suggestion for the next steps.

Note:

We were able to resolve 200 (low + medium) errors and 200 warnings in 1 PD using this approach.
If your application has custom logic coded in UI. Recommendation would be to break a big controller task into small steps for Cline. This would improve the efficiency of the solution being generated.
Considerable effort reduction can be achieved once initial steps are eased into.
Approximately 30-40% of manual effort is saved with the approach suggested. Once the confidence in AI suggestions improve, the number might be higher.

Tags: #SAPUI5 #Fiori #DeprecatedCode #AI #Cline #SAPDevelopment