Skip to content
Matthias Stegmüller

Case study 01SAP Joule Work2025 — 2026

Concept & direction

Designing the human side of Autonomous AI.

As AI agents move from answering questions to executing business processes, a new design challenge emerges: how do people delegate responsibility, stay informed, and remain in control? I developed the Jobs concept to address this challenge, establishing a new interaction model for autonomous work in SAP Joule Work – SAP's new Enterprise AI Workspace.

The Jobs view from the concept prototype: a list of active Jobs and the weekly margin review waiting for its next run, with the previous run's summary and exceptions, what the Job monitors and the actions it may take on its own
Concept prototype · synthetic data

At a glance

  1. 01The problem

    Chat can't hold a commitment

    Once AI does real business work, people become its supervisors. A conversation has no state, no limits anyone can inspect, and no record an auditor can trust.

  2. 02What I did

    Identified the opportunity, defined the concept, influenced product strategy

    Led concept through iterative prototypes and customer validation. Beyond design, I took on product responsibilities and secured leadership support for making Jobs a core part of Joule Work.

  3. 03The result

    A core concept of Joule Work, now in development

    Adopted as one of five core concepts of Joule Work. Customer studies validated the Job definition. The first release, scheduled Jobs, is in development.

01

The problem

Chat can't hold a commitment

Enterprise software runs the business. Once AI takes over part of that work, people stop operating each step themselves and become supervisors of work that agents carry out.

The default assumption was to follow the consumer AI tools: a chat, maybe a scheduled task. Without a shared container for delegated work, every team would invent its own execution UI, monitoring would fragment, audit trails would diverge, and trust would collapse. A supervisor needs four answers that a chat transcript can't give.

  1. 01

    What is running

    Which work has been handed to AI, on whose behalf, towards which outcome.

  2. 02

    Under which conditions

    The scope, limits and autonomy it runs under, in business terms.

  3. 03

    When I'm involved

    Where the work will stop for my judgment, and what I'll see when it does.

  4. 04

    What happened before

    Every past run, inspectable: what was done, by whom, and why.

02

Making the case

From “why would we need this?” to a core concept

In November 2025, as part of the small initial project team, I noticed that nothing in our plans described what it means to hand work to AI. At every two-week sprint I demoed the concept to leadership, including board members, and defended it in the room. Their first reaction: we already have agents and assistants. Why add Jobs?

I read that as a problem with the explanation, not the idea. We'd pitched Jobs as a new way to get work done, so it sounded like a rival to things leadership already believed in. I changed the question: agents execute work and Joule orchestrates them, but where do we persist the execution contract, and every decision AI and people made in each run? Nothing in the plan answered that.

The demos grew with the argument, from Figma and Figma Make prototypes to live code on an agent harness with orchestrated sample agents, which proved the contract could hold a real run. We had no PM, so I took on that role too. My biggest lesson: much of the work was setting context, so every new person in a growing room started from the same problem.

How the pitch changed

  1. 01

    First version

    Jobs as a new way for AI to do work. It sounded like a duplicate of agents and assistants.

  2. 02

    Revised version

    Jobs as the contract around work that agents, assistants and workflows already do.

The analogy that worked best was building a house. Talking to an architect commits nothing. Signing with a general contractor creates a defined outcome, someone accountable, specialists who come and go, and the right to ask at any time where things stand. A conversation with Joule is the architect, a Job is the contract, agents are the specialists. Three to four months after I spotted the gap, leadership made Jobs one of five core concepts of Joule Work.

03

The model

Designing a new model for delegating work to AI

03.1

Jobs as the unit of delegated work

AI agents execute tasks. Workflows coordinate steps. Assistants help people interact with systems. But none of these, on its own, represents the business commitment someone has delegated to AI.

I developed Jobs as a persistent, governed unit of work that connects business intent with execution.

A Job defines the desired outcome, its owner, the conditions under which work should happen, the boundaries of autonomous execution, and when human judgment is required. It connects the capabilities doing the work with the progress, decisions, results and history people need to supervise it.

A Job owns the context of the work, not the mechanics of execution. Agents can be swapped, switched mid-run or retried, and monitoring, approvals and audit still have one object to attach to.

DiagramJobs sit between the Joule Work experience and the execution layer. The Job holds the outcome and its context; agents, workflows and tools do the work and can change.

Job

3 groups · 10 parts

01Definition & governance

02Execution & supervision

03Outcomes & evidence

Intent summary · Defined & governed

Why the Job exists, in the user's language.

Specific enough to answer later: what was this Job trying to achieve? It sets the purpose and gives everything else in the Job its direction.

Example (synthetic)

Identify gross margin deviations above 5% against budget across European business units and propose compliant adjustments.

In the bigger picture
  • Defined & governed
  • Configured within limits
  • Maintained during execution
DiagramWhat a Job is made of, in three groups: what is agreed before work starts, what is kept while it runs, and what is recorded afterwards. Select a part to see what it holds. Examples are synthetic.

03.2

Where Jobs come from

A Job doesn't have to be created from scratch. It can be delivered by SAP, provisioned by an organization, or created by an individual. Each path offers a different balance of flexibility, control and enterprise readiness.

  1. 01

    Out-of-the-box Jobs

    Delivered by SAP

    Jobs for predefined business scenarios, with established capabilities, default configurations and governance boundaries.

    Available Job templates
    • Monitor blocked paymentsUse
    • Review margin deviationsUse
  2. 02

    Organization-provisioned Jobs

    Configured by IT, admins or partners

    Configured for a specific business context: capabilities connected, permissions defined, and made available to the right users.

    Configure & publish

    Capabilities · Policies · Roles

    Available to Finance Operations

  3. 03

    User-created Jobs

    Described by a person

    People describe what they want to achieve, for example in Joule chat. The system turns that intent into a structured Job, using only permitted capabilities and autonomy limits.

    Delegate an outcome

    “Monitor overdue confirmations and alert me when orders are at risk.”

    Review proposed Job definition →

One model

Same Job contract, governance and supervision

DiagramThree ways to create and provision Jobs. The screens inside each path are illustrative.

These are three paths into the same Job model, not three kinds of Jobs. Whatever its source, every Job carries the same contract, the same governance and the same supervision.

The concept covers all three paths. The first release starts with one: scheduled Jobs that business users delegate themselves. Because every path leads into the same model, the others can follow without changing how people supervise their Jobs.

03.3

From definition to execution and supervision

  1. 01

    Define

    Outcome, scope and rules

  2. 02

    Activate

    Start or schedule work

  3. 03

    Supervise

    Monitor and intervene

  4. 04

    Review

    Results and history

Runs
  • Run · Mon 08:00
  • Run · Tue 08:00
  • Run · Wed 08:00
  • …

Each run has its own status, decisions and execution history.

DiagramConceptual lifecycle. Recurring Jobs can produce many runs, each with its own status, decisions and execution history.

A Job is not the same as a run. The Job persists as the definition and the context for supervision. A run is one execution: it produces progress, actions, exceptions and results.

A recurring Job that monitors order confirmations might run every morning. Each run has its own findings and decisions, while the Job stays the stable object through which a business user manages that responsibility.

03.4

One model, different perspectives

Business users prioritise outcomes, progress, exceptions and decisions. Technical users prioritise capabilities, reliability, diagnostics and execution history. A finance lead asks what business work is being done and what came out of it; an agent developer asks which capabilities ran, how reliably, and where they failed.

I detailed a lens for each, both on the same Jobs, runs and outcomes, as part of sharpening the pitch: it showed why Jobs had to be a shared object rather than a feature of one audience's tool. I then worked them through with SAP's head of design.

One model

Jobs · runs · capabilities · outcomes

Jobs lens

Business users

What business work is the system doing, and what outcomes does it deliver?

  • Operator · planner · finance lead

    “I assign outcomes. The system tells me only when it needs my judgment.”

    1 Signals & exceptions2 Job3 Runs

  • Domain expert · analyst

    “I need to understand the signals, results and reasoning.”

    1 Anomalies2 Runs3 Outcomes

  • Manager · process owner

    “Is AI improving performance, and where is attention needed?”

    1 Business KPIs2 Outcomes3 Jobs

Capability lens

Technical users

Does the system execute work reliably, and which capabilities make sure it does?

  • Automation owner · power user

    “Which capabilities power my Jobs, and how well do they perform?”

    1 Outcomes2 Capabilities3 KPIs

  • Agent developer

    “Agents orchestrate capabilities within governance rules.”

    1 Agents2 Runs3 Jobs

  • AI / IT architect

    “Where do risks or failures occur in execution?”

    1 Failures2 Agents3 Runs

Numbers show each persona's first three priorities. Same objects, different entry points and different order of importance.

DiagramSame objects, different entry points and priorities. Personas and priorities from the concept.

03.5

Governance and autonomy

Enterprise autonomy needs layered authority. The company sets guardrails per domain, an agent harness every Job runs inside. The Job's source (built in by SAP, provided by IT, or defined by a user) sets defaults within them. The accountable person can always tighten them, and widen them only up to the guardrail. What's in force, and who set it, is recorded with every run.

  1. 01

    Company guardrails

    Set per domain by the organisation. Levels beyond them can't be chosen.

    Off limitsin the grid

  2. 02

    Job source

    SAP, IT, a partner or a user. Sets the default within the guardrails.

    Defaultin the grid

  3. 03

    You

    The accountable person. Can always tighten, and widen up to the guardrail.

    Your settingin the grid

Click a level to change what Joule may do on its own.

  • Draft explanations for margin deviations

    Supervised. Joule does it and tells you. You can step in.

    Job default · Guardrail: no limit beyond the Job's scope

  • Post a prior-period adjustment

    Assistive. Joule prepares it. You confirm every time.

    Job default · Guardrail: automatic only below €50k

  • Change vendor bank details

    Assistive. Joule prepares it. You confirm every time.

    Job default · Guardrail: dual control required

  • Release a blocked payment

    Manual. You do it. Joule only analyses and recommends.

    Fixed by the company guardrail · Guardrail: payments always stay with people

What's in force for each action, and who set it, is recorded with every run.

DiagramTry it: change the autonomy for an action. You can't widen it past the company guardrail. Illustrative actions.

04

Designing the experience

From model to interface

04.1

From conversation to Job

Beyond chat doesn't mean without chat. People still start in a conversation. When a request needs to outlive it, Joule drafts a Job next to the chat for review, and nothing runs until the person activates it.

The person says what they want

In their own words, in a conversation.

Example (synthetic)

“Review gross margin deviations above 5% across my European business units every Monday and suggest adjustments.”

In the prototype
Joule conversation: the user asks for a weekly margin review across Europe, Joule asks whether to recommend or auto-correct, the user sets a €50k approval threshold, and Joule replies with a drafted Job summary, a Job draft card and an Activate job button
DiagramFrom request to Job, as defined in the concept. Step through it. Below, the same flow in the prototype: Joule asks only what it can't infer, drafts the Job in the conversation, and nothing runs until the person activates it. Prototype data.

04.2

Supervising many Jobs

A process owner rarely watches a single Job. The Jobs overview answers three questions at a glance: how much runs without people, how often they step in, and which Jobs need attention.

Jobs dashboard with KPI tiles for SLA compliance rate, average time to resolution, autonomy ratio, human intervention rate and active Jobs, above a list of three active Jobs, each with its last update, scope, risk rule, a status such as Monitoring, Waiting for Event or Waiting for Schedule, and a small chart
The Jobs overview for a process owner. Figures are prototype data.
PrototypeThe Jobs overview for a process owner. Figures are prototype data.

04.3

Making AI work visible in business terms

Agents work in technical steps. The people responsible for the outcome need to see that work in a consistent way, in terms that matter to their business. Every Job shows its live status the same way: what it is doing right now, what it observed, what it resolved on its own, what it monitors, and which actions it may take without asking.

Live status of an accrual monitoring Job: current activity, latest observation (signals processed, pattern checks, open investigations), autonomous resolution (anomalies auto-cleared, recommendations, escalations), monitoring scope and automatic actions allowed
Live status of one Job: current activity, what it observed, what it resolved on its own, what it monitors and what it may do without asking. Prototype data.
PrototypeLive status of one Job: current activity, what it observed, what it resolved on its own, what it monitors and what it may do without asking. Prototype data.

04.4

Making exceptions actionable

When a run finds something, it explains each exception in business terms: the deviation, its driver and its status. From there, the person opens the investigation, or makes the decision the Job is waiting for.

Details of a completed run: three business units over the margin threshold, each with deviation, driver and status, above a timeline of the run
A completed run explains each exception in business terms (deviation, driver, status), with a link into its investigation.
PrototypeA completed run explains each exception in business terms (deviation, driver, status), with a link into its investigation.

04.5

Inspecting outcomes and history

Detail stays one level down, never gone. The run history lists every run of a Job: what triggered it, what it processed, what it found, what it did and how it ended. Runs waiting for a person stay marked until someone decides. Each run opens into its full timeline and audit trail, down to the policy that applied and the authority it ran under.

Run history of an accrual monitoring Job: each run with start time, trigger type, scope, signals processed, anomalies, actions taken, duration and summary, two of them pending a decision
Run history of a monitoring Job: per run, what triggered it, what it processed, what it found and what it did. Runs waiting for a person show Pending Decision. Prototype data.
PrototypeRun history of a monitoring Job: per run, what triggered it, what it processed, what it found and what it did. Runs waiting for a person show Pending Decision. Prototype data.

05

Design decisions

The design decisions that shaped Jobs

Jobs didn't start as an architecture. It came out of four decisions, each a choice between models that could all have worked. The fifth, how to pitch it, is told above under Making the case.

06

With customers

What customers told us

After each workshop we put the concept in front of customers. I initiated and directed the research; the researcher on my team ran it. In one study, finance and operations users from five companies walked through the Jobs screens one by one, then ran a SWOT on the concept.

What we learned

  1. 01

    The contract is the right abstraction

    The Job definition was the most praised part of the concept, at the right level of abstraction for business users. “Job” itself was readily understood.

  2. 02

    Trust is earned over the first runs

    People would inspect the first two or three runs in detail, then stop checking. They don't watch a running Job; they want to know when to come back.

  3. 03

    Technical detail belongs one level down

    The agents and capabilities section read as too technical, which confirmed supervising by outcome.

  4. 04

    Accountability needs more than one name

    Auditors ask who created a Job, who started a run and who changed what. Failures need recording as fully as successes.

  5. 05

    A Job definition is knowledge to share

    People wanted to copy definitions as templates and find what colleagues had built.

Where customers pushed back

  1. 01

    Authorisation boundaries

    In regulated finance, the fear is an agent posting with the wrong tax code. Governance, not usability, will decide adoption.

  2. 02

    No safe way to try it

    Participants asked for a dry run before the real one.

  3. 03

    Too much configuration

    People wanted sensible defaults, which supports setting autonomy at company and Job level.

07

Reflection

What I'd do differently

The first release of Jobs will focus on scheduled Jobs that business users create themselves. It's a pragmatic starting point, but I believe we underestimated an important enterprise requirement: companies want to control which agentic work is made available to their employees, under what conditions, and with which responsibilities.

Our customer engagements reinforced this. Business users aren't necessarily looking to build their own automations. They want to delegate meaningful work to trusted capabilities that their organization has already configured, approved, and provisioned. Their role shifts from creating automation to supervising outcomes, handling exceptions, and making decisions where human judgment is required.

Looking back, I would have connected the long-term Jobs concept to a more representative first release: predefined, governed Jobs provisioned by SAP or the enterprise, which business users can activate and supervise. This would have demonstrated the value of the execution contract from day one, while keeping the initial scope manageable.

The lesson for me is that defining the right long-term vision isn't enough. The first product slice must validate the core assumptions behind that vision, not simply deliver the easiest capability to implement.

  • Strategic influence

    One of five core Joule Work concepts

    Leadership adopted Jobs as one of five core concepts of Joule Work, alongside chat, spaces, discover and skills.

  • Concept validation

    Tested with customers

    A customer study after every sprint workshop. Customers understood the separation between delegating a business outcome and executing the work through agents: they rated the Job definition the right level of abstraction and found the agent detail too technical.

  • Product realization

    First release in development

    The first release, scheduled Jobs, is in development, with the full execution-contract model as the direction beyond it. Not yet released; business impact remains to be measured.

What I learned

  • Enterprise AI is about governed delegation, not personal automation.

    Customer engagements reinforced that businesses want to provision trusted agentic capabilities, while employees operate them, supervise outcomes, and intervene when needed. This has important implications for where the product should start.

  • A strong vision needs an equally strong first release.

    We established Jobs as a core concept, but the initial implementation focuses on user-created scheduled work. In hindsight, I would have pushed harder for a first release that demonstrates enterprise-provisioned Jobs and their governance model.

  • Conceptual clarity is a leadership responsibility.

    The breakthrough came when I stopped positioning Jobs as another way to execute work and established them as the accountable contract around agents, assistants, and workflows. Getting the model right changed the conversation with leadership.

Still open

  • How should enterprises provision agentic work at scale?

    What should SAP deliver out of the box, what should organizations configure, and what freedom should individual users have?

  • How do we balance autonomy with accountability?

    Who can authorize autonomous actions, and how do we ensure responsibility remains clear as work crosses agents, systems, and people?

  • How do we measure successful delegation?

    Beyond execution success, how do we demonstrate reduced manual effort, better decisions, and improved business outcomes?