The SAP Business AI landscape: where every piece sits

#The 60-second version

SAP sells AI in several places at once. Some of it is already inside the applications you run. Some of it is a toolkit for building your own. Some of it is data and governance that sits underneath both. The names change often, which makes the whole thing look more complicated than it is.

A simple way to hold it: five layers, from what users see down to what keeps it safe.

1. Where people work: Joule, SAP's AI assistant, in SAP applications.
2. What SAP ships ready-made: AI features and agents inside SAP applications.
3. What you build: Joule Studio for custom agents, apps and workflows, plus integration.
4. What the AI knows and thinks with: business data, business context and models.
5. What keeps it under control: inventory, permissions and monitoring of every agent.

Since SAP Sapphire in May 2026, SAP groups layers 3 to 5 under one name: the SAP Business AI Platform. It brings together SAP Business Technology Platform (BTP), SAP Business Data Cloud and SAP Business AI into one governed environment.

#Why it matters to the business

Most wasted AI money in SAP shops comes from placing a use case in the wrong layer.

• Building what you already own. A team spends a quarter building a custom agent for something SAP now ships in the application, sometimes covered by licenses the company already pays for.
• Buying what doesn't fit. A standard feature is licensed, then goes unused because the company's process differs from SAP's standard.
• Building on sand. A custom agent works in the demo, then fails in production because nobody sorted out the data, the authorizations or who governs it.

Take the running example: blocked sales orders in order-to-cash. Credit analysts review orders stuck on credit or delivery blocks. Where should AI help?

• If SAP ships an agent that monitors orders for your application and release, start there. In the Q2 2026 release highlights, SAP listed an Order Reliability Agent in beta for continuous order monitoring.
• If your credit rules are unusual, a custom agent built in Joule Studio may fit better.
• Either way, the agent needs trusted data about customers, payments and orders, and someone has to decide what it is allowed to change.

The landscape is a map for making that call on purpose.

#How SAP does it

As of September 2026, based on SAP's product pages and Sapphire 2026 announcements:

SAP's own framing of the platform uses three pillars: Build, Contextualize & Reason, and Govern. The five layers above add the two layers users meet directly: Joule and the applications.

#How it is paid for

SAP's commercial model splits Joule in two, per SAP Learning's Joule course:

• Joule Base covers navigational, informational, transactional and simple analytical capabilities. It comes with your SAP product license.
• Joule Premium covers advanced capabilities, embedded AI features and actions taken by Joule agents. These consume AI Units, a virtual currency bought in advance.

Joule Studio has its own offer: SAP announced free design-time access for customers and partners through the end of 2026, under fair-use limits. Running agents in production is a separate question. Ask your account team what it costs.

#A decision guide: which layer first?

Work top-down. Stop at the first layer that solves the problem well enough.

#Questions to ask

Ask your team, your SAP account team or your implementation partner:

• For this process, what AI does SAP already ship in our release and edition, and what is its availability status: GA, beta or Early Adopter Care?
• Which of these features is in Joule Base, and which consumes AI Units? What would a year of use cost at our volumes?
• If we build a custom agent, where does it run, who operates it, and what does it cost to run after the free design-time period?
• What business data will the agent see, and does it respect each user's SAP authorizations?
• How will we inventory and monitor every agent, including ones built outside SAP?
• What happens to our build if SAP ships the same capability as standard next year?

#Common misconceptions

• "Joule is one product." Joule is the name on the assistant, the agents, the assistants that coordinate agents, and the building tool (Joule Studio). Ask which one someone means.
• "The SAP Business AI Platform is a new system to install." It is SAP's grouping of existing and new services, including BTP capabilities, Business Data Cloud and the AI services, under one name and governance.
• "If it was announced, we can use it." Many Sapphire announcements start in beta or Early Adopter Care. Check the status for your region and release.
• "AI in SAP only works with SAP's own models." The generative AI hub gives access to models from several vendors, plus SAP's own.
• "Custom agents are always the advanced option." A standard agent you can switch on this quarter often beats a custom one you maintain forever.

#Key terms

• Joule: SAP's AI assistant in SAP applications.
• Joule agent: An AI agent that performs a task in a business function.
• Joule Assistant: A role-based assistant that coordinates several agents for a person.
• Joule Studio: SAP's environment for building custom agents, apps and workflows.
• SAP Business AI Platform: SAP's umbrella, since May 2026, for its build, context and governance layers.
• SAP Business Data Cloud: SAP's data foundation for AI and analytics.
• Generative AI hub: The part of SAP AI Core that provides access to many language models and orchestration tools.
• AI Units: SAP's prepaid currency for premium AI capabilities.
• Early Adopter Care: An SAP program that gives selected customers access before general availability.

#Check yourself

#Mental model: five layers, one request path

Every AI use case in an SAP landscape touches the same five layers. The question is never "which product?" but "which layer does the work, and which layers does it depend on?"

flowchart TB
  E["Experience: Joule, Joule Work"]
  A["Applications: embedded AI, Joule agents and assistants"]
  B["Build: Joule Studio, Integration Suite"]
  C["Context and models: Business Data Cloud, Knowledge Graph, generative AI hub, SAP-RPT-1"]
  G["Govern: AI Agent Hub, AI Launchpad"]
  E --> A
  E --> B
  A --> C
  B --> C
  G -.-> A
  G -.-> B
  G -.-> C

Two rules follow from the picture.

1. Users enter at the top. Whatever you build should surface where people already work. In SAP's direction of travel, that is Joule.
2. Governance crosses every layer. An agent you build and an agent SAP ships need the same inventory, permissions and monitoring.

The build, context and governance layers are what SAP now calls the SAP Business AI Platform. SAP's product page says BTP capabilities are a core part of it. So the BTP services you know did not disappear; they moved under a new umbrella.

If you read the SAP FDE topic, this is the map behind its first architecture decision: where should the AI live?

#How it works

It helps to trace one request through the layers. The sequence below is an illustrative path, drawn from how SAP describes each component. It is not SAP's documented internal call sequence.

sequenceDiagram
  participant U as Credit analyst
  participant J as Joule
  participant AG as Agent
  participant D as Data and context
  participant M as Model
  participant GV as Governance
  U->>J: Which blocked orders can I release today?
  J->>AG: Route to the right agent
  AG->>D: Read orders, payments, credit data
  D-->>AG: Business data with context
  AG->>M: Reason over data and policy
  M-->>AG: Draft recommendations
  AG-->>J: Recommendations with evidence
  J-->>U: List to review and approve
  GV-->>AG: Inventory, permissions, monitoring

Now the layers one at a time, as of September 2026.

#Experience: Joule and Joule Work

Joule is the assistant embedded in SAP cloud applications. SAP's commercial model splits its capabilities into Joule Base, included with product licenses, and Joule Premium, which consumes AI Units.

Joule Work, announced at Sapphire 2026, lets users state a business outcome while Joule coordinates workflows, data and agents. The Q2 2026 release highlights list Joule Work in SAP Early Adopter Care, with registrations closed, and the Joule Work mobile app as generally available.

#Applications: embedded AI, agents and assistants

SAP ships AI inside its applications in three forms:

• Embedded AI features in specific apps, for example AI-assisted extraction in SAP Ariba Invoicing (GA in Q2 2026).
• Joule agents, which automate tasks in a business function.
• Joule Assistants, which SAP describes as role-based assistants that coordinate multiple agents.

At Sapphire 2026, SAP announced the SAP Autonomous Suite with more than 50 domain-specific Joule Assistants and more than 200 specialized agents across finance, supply chain, procurement, HR and customer experience. Individual agents have their own status. For example, the Q2 2026 highlights list the Order Reliability Agent and the Project Billing Price Verification Agent as beta, and the Expense Automation Agent as GA.

#Build: Joule Studio and Integration Suite

SAP announced a new, fully managed Joule Studio in May 2026. Per the announcement, it covers:

• Intent-based development: describe a goal and get a requirements document, code scaffolding, tests and a working preview.
• Pro-code: use Visual Studio Code or Cursor, with frameworks such as LangChain, Pydantic AI and LlamaIndex.
• An embedded, managed n8n environment for visual multi-agent orchestration.
• Joule Studio Runtime: managed deployment, with sandboxed agent environments.

The Q2 2026 highlights list Joule Studio in SAP Early Adopter Care. Confirm what is generally available in your region before you plan a delivery on it.

SAP Integration Suite is the integration layer. SAP's platform page describes it as connecting AI agents, applications, data and systems across the enterprise.

#Context and models

This is the layer that makes SAP's AI different from a generic chatbot. Three pieces matter.

• SAP Business Data Cloud (BDC) is SAP's data foundation. SAP's platform page lists SAP Datasphere, SAP Analytics Cloud, SAP HANA Cloud, SAP Business Warehouse, SAP Master Data Governance, SAP Databricks and SAP Business Data Cloud Connect among its components. In May 2026, SAP said HANA Cloud is now a core component of BDC.
• SAP Knowledge Graph encodes business entities, processes and their relationships so AI can reason with business meaning, not just raw tables.
• Generative AI hub is part of SAP's AI Foundation, within SAP AI Core. It gives access to models from several providers, SAP-hosted and self-hosted options, and an orchestration service with content filtering, data masking and grounding. You reach it through SAP AI Launchpad or programmatically through APIs and SDKs.

SAP also lists its own models as platform components: SAP Domain Models, trained on SAP knowledge, and SAP-RPT-1, a model for predictions on tabular business data that needs no training or fine-tuning. Tabular AI is covered in Unit 12.

#Govern: AI Agent Hub

SAP AI Agent Hub is SAP's control point for all AI agents, LLMs and MCP servers across the enterprise. The Q2 2026 highlights list it as generally available, with automated discovery and governance verification badges. SAP's platform page calls this governance layer a command center with visibility and control over every agent, LLM and MCP server.

SAP AI Launchpad and SAP AI Core remain the tools for managing the model lifecycle.

#Build it yourself: a landscape placement tool

You will use the landscape to place use cases many times in this course. Encode it once, as a small tool you can re-run when SAP changes things.

The script below describes one use case with five yes/no answers, prints which layers and SAP components are worth evaluating, and prints a mermaid diagram (a text format that tools turn into a picture) you can paste into a design document. It needs only Python itself: no SAP account, no API key and no extra libraries.

#Run it step by step

Before you start: complete Set up your computer for this course. It installs Python and creates your course folder. Then:

1. Open VS Code, copy the whole script below and save it as landscape.py in the unit01 folder of your course folder.

2. In the terminal, with (.venv) showing, move into that folder with cd unit01.

3. Run:

   Copy

   python landscape.py

   (Use python3 on macOS or Linux if python isn't found.)

4. You should see a Landscape snapshot as of ... line, then five headings (experience, applications, build, context_and_models, govern), each with one or more suggestions, then a Notes: line, then a block starting with flowchart TB.

5. To see the diagram, copy everything from flowchart TB to the end, open mermaid.live, and paste it into the code panel on the left. The picture appears on the right.

6. To try your own use case, find the block that starts with blocked_orders = UseCase( near the bottom. Change the name and process text, and set each True/False to your honest answer. Save and run again.

"""Place an AI use case on the SAP Business AI landscape.

A thinking tool, not an SAP product catalog. Statuses are a snapshot you
must re-check against SAP sources before you use them in a real proposal.
"""
from dataclasses import dataclass, field

AS_OF = "2026-09"

# Layer -> components, with a status note you maintain from sources.
LANDSCAPE = {
    "experience": {
        "Joule": "Joule Base included with SAP product licenses",
        "Joule Work": "Early Adopter Care (Q2 2026)",
    },
    "applications": {
        "Embedded AI features": "status per application and release",
        "Joule agents and assistants": "status per agent: GA, beta or EAC",
    },
    "build": {
        "Joule Studio": "new managed version in Early Adopter Care (Q2 2026)",
        "SAP Integration Suite": "check",
    },
    "context_and_models": {
        "SAP Business Data Cloud": "check",
        "SAP Knowledge Graph": "check",
        "Generative AI hub (SAP AI Core)": "check",
        "SAP-RPT-1": "check",
    },
    "govern": {
        "SAP AI Agent Hub": "GA (Q2 2026)",
        "SAP AI Launchpad": "check",
    },
}


@dataclass
class UseCase:
    name: str
    process: str
    standard_feature_exists: bool   # does an SAP app already ship this?
    needs_custom_logic: bool        # company-specific rules or steps
    acts_across_systems: bool       # reads or writes outside one SAP app
    data_is_tabular: bool           # predict a field from table rows
    uses_documents: bool            # policies, contracts, manuals
    notes: list = field(default_factory=list)


def place(uc: UseCase) -> dict:
    """Return the layers and components worth evaluating, with reasons."""
    picks = {layer: [] for layer in LANDSCAPE}

    # Always start where users already work.
    picks["experience"].append("Joule: can users ask for this where they work?")

    if uc.standard_feature_exists:
        picks["applications"].append(
            "Embedded AI features / Joule agents and assistants: evaluate first"
        )
        uc.notes.append("Standard exists: prove the gap before building.")

    if uc.needs_custom_logic or not uc.standard_feature_exists:
        picks["build"].append("Joule Studio: custom agent or workflow")
    if uc.acts_across_systems:
        picks["build"].append("SAP Integration Suite: connect non-SAP systems")

    if uc.data_is_tabular:
        picks["context_and_models"].append("SAP-RPT-1: tabular prediction")
    if uc.uses_documents or uc.acts_across_systems:
        picks["context_and_models"].append(
            "SAP Business Data Cloud / Knowledge Graph: business context"
        )
    if uc.needs_custom_logic or uc.uses_documents:
        picks["context_and_models"].append(
            "Generative AI hub: models, orchestration, grounding"
        )

    # Governance is never optional once an agent can act.
    picks["govern"].append("SAP AI Agent Hub: register and govern the agent")
    return {k: v for k, v in picks.items() if v}


def to_mermaid(uc: UseCase, picks: dict) -> str:
    lines = ["flowchart TB", f'  UC["{uc.name}"]']
    for i, (layer, items) in enumerate(picks.items()):
        lines.append(f'  L{i}["{layer}"]')
        lines.append(f"  UC --> L{i}")
        for j, item in enumerate(items):
            label = item.split(":")[0]
            lines.append(f'  L{i}_{j}["{label}"]')
            lines.append(f"  L{i} --> L{i}_{j}")
    return "\n".join(lines)


if __name__ == "__main__":
    blocked_orders = UseCase(
        name="Triage blocked sales orders",
        process="order-to-cash",
        standard_feature_exists=True,   # check what your release ships
        needs_custom_logic=True,        # company credit rules
        acts_across_systems=True,       # e.g. a bank portal for payments
        data_is_tabular=True,           # predict likely release
        uses_documents=True,            # credit policy PDF
    )
    picks = place(blocked_orders)
    print(f"Landscape snapshot as of {AS_OF}\n")
    for layer, items in picks.items():
        print(layer)
        for item in items:
            print("  -", item)
    print("\nNotes:", *blocked_orders.notes, sep="\n  ")
    print("\n" + to_mermaid(blocked_orders, picks))

For the blocked-orders case you get all five layers, starting with "evaluate the standard first", and a diagram.

Three design choices are worth copying into real work:

• The status lives next to the component, with a date. When SAP moves something from Early Adopter Care to GA, you change one line.
• "Standard exists" produces a note, not a silent skip. The tool makes you prove the gap before you build.
• Governance is unconditional. Every placement ends with registering the agent.

#The SAP way

The placement tool tells you where to look. Here is what you find when you get there, and how you would start.

#Calling a model through the generative AI hub

Most custom work touches the generative AI hub, even when Joule Studio hides it. The SAP Cloud SDK for AI (Python), published on PyPI as sap-ai-sdk-gen, wraps the orchestration service. The sketch below follows the V2 orchestration examples in SAP's SDK reference. It needs an SAP AI Core instance and credentials, so treat it as a sketch to read, not to run yet; check class names against the SDK version you install.

# Sketch: requires SAP AI Core credentials (AICORE_* environment variables
# or a config file). pip install "sap-ai-sdk-gen[all]"
from gen_ai_hub.orchestration_v2.models.message import SystemMessage, UserMessage
from gen_ai_hub.orchestration_v2.models.template import (
    Template, PromptTemplatingModuleConfig,
)
from gen_ai_hub.orchestration_v2.models.llm_model_details import LLMModelDetails
from gen_ai_hub.orchestration_v2.models.config import ModuleConfig, OrchestrationConfig
from gen_ai_hub.orchestration_v2.service import OrchestrationService

template = Template(template=[
    SystemMessage(content="You explain SAP credit blocks to credit analysts."),
    UserMessage(content="Summarize why this order may be blocked: {{?order_facts}}"),
])
llm = LLMModelDetails(name="gpt-4o")  # use a model available in your region
config = OrchestrationConfig(
    modules=ModuleConfig(
        prompt_templating=PromptTemplatingModuleConfig(prompt=template, model=llm)
    )
)
service = OrchestrationService(config=config)
result = service.run(placeholder_values={"order_facts": "..."})
print(result.final_result.choices[0].message.content)

The value of going through orchestration instead of calling a model vendor directly: the same configuration can add data masking, content filtering and grounding, and you can swap models without changing your app. Model choice and orchestration get a full treatment in Unit 5.

#What each layer asks of you

#Licensing notes

• Joule Base is included with SAP product licenses. Joule Premium capabilities, including embedded AI features and agent actions, consume AI Units.
• AI Units are a consumption-based currency shared across SAP solutions. Plan consumption, not just purchase.
• Joule Studio design-time access is free for customers and partners through the end of 2026 under fair-use limits, per SAP's May 2026 announcement. Production runtime is priced separately; get a quote.
• The generative AI hub runs on SAP AI Core, which you provision in your SAP BTP global account. Budget model consumption separately from Joule.

#Build vs. SAP

The pattern: move down the table only when the row above fails, and write down why.

#Production concerns

• Authorizations. An agent that reads orders for a user must not show orders that user cannot see in SAP. Decide early whether the agent acts with the user's identity or a technical user. Unit 11 covers this in depth.
• Status risk. Beta and Early Adopter Care features can change or be withdrawn. Do not put a beta capability on the critical path of a go-live without a fallback.
• Cost visibility. AI Units, AI Core consumption and Joule Studio runtime are metered differently. Set up one view of AI spend per use case before scaling.
• Governance scope. Inventory every agent and MCP server, not only SAP's. Ask how AI Agent Hub covers the non-SAP agents in your landscape: the risky agent is usually the one nobody registered.
• Clean core. Custom AI belongs in side-by-side extensions and released APIs, not modifications to SAP standard. Unit 6 and Unit 13 cover the patterns.
• Evaluation. Standard or custom, measure the agent on your own data before trusting it. Unit 8 covers evaluation.

#Pitfalls

• Treating an announcement as a delivery date. Sapphire announcements often start in Early Adopter Care. Plan on GA status in your region.
• Mixing up "Joule" meanings. Joule, Joule agents, Joule Assistants, Joule Work and Joule Studio are different things with different costs. Name the exact one in every design document.
• Skipping the data layer. Agents fail quietly on messy master data. The data work in Business Data Cloud or integration is usually bigger than the agent.
• Ignoring older names. Customers and partners still say SAP BTP and AI Foundation. Map old names to the new platform instead of correcting people.
• Building a lock-in you didn't intend. A custom agent tied to one model or one vendor's runtime is hard to move. Keep prompts, tools and evaluations portable.

#Exercise: a landscape map for one use case

Use the placement tool for a use case from your own work, or one of the course examples: blocked sales orders, three-way match exceptions, or MRP exceptions.

1. Save and run the script as described in "Run it step by step", then change the UseCase(...) block to your use case with honest answers to the five questions.
2. For each component the tool suggests, open one current SAP source and record its status (GA, beta, Early Adopter Care or unknown), the date and the URL.
3. Update the LANDSCAPE statuses from what you found.
4. Write a one-page decision note: which layer does the work, what it depends on, what you would pilot first, and what would change your mind.
5. Paste the generated mermaid diagram into the note.

Done when you have a decision note with a diagram, a dated status for every component it names, and one sentence explaining why the standard SAP option is or isn't enough. Keep it: you will reuse it for the solution design document in Unit 6 and the opportunity assessment in Unit 14.

#Check yourself