logo

Are you need IT Support Engineer? Free Consultant

5 things I learned facilitating SAP's Agentic AI training in 2026

  • By sujay
  • 15/11/2026
  • 25 Views

5 things I learned facilitating SAP's Agentic AI training across Ireland in 2026

In July 2026 I made a decision to actively rebuild my SAP AI skills. Four months later I had facilitated five two-day Agentic AI sessions, earned my C_JSD (Joule Studio Developer) certification, and stood in front of hundreds of SAP professionals teaching them how to build Joule agents. This post is not about what I taught them. It is about the five things they taught me.

Point 1  : Every room had a moment where the AI stopped being theoretical

In every session, there was a point where a participant stopped typing and said something like “wait, this actually works.”  It was never the demo that did it. It was the moment they built something themselves, even something small, and it responded intelligently. The energy in the room shifted. What had been theoretical for weeks became something they could see, touch, and imagine using. The excitement on people's faces in that moment is something I will not forget. Not because it was impressive technology, but because you could see them thinking about their own work, their own problems, their own teams.

The training gives people permission to start. It gives them the hands-on time to try, to fail safely, to get their questions answered in real time. And in that moment when something works for the first time, something shifts. They stop waiting for someone else to figure this out. They become the person who is going to figure it out. I know this because the same thing happened to me.

The insight: The gap between knowing AI exists and believing it can solve your business problem closes in a hands-on session, not in a presentation. The sooner we can create that moment for people, the better.

Point 2 : The question that stopped every room: Who owns the agent's output?

Every single session someone asked a version of this question. It came up in different forms: “If the agent makes a mistake, who is responsible?” “Can we trust this in a production workflow?”  “What happens when the agent does something unexpected?”  The room went quiet. I could see people nodding. This was the real question underneath all the excitement about agentic AI.

My answer surprised a few people: the agent does not own anything. It never did. The same person who would have walked into the CEO's office if a badly configured workflow caused that mistake will still walk in. What changes with agentic AI is not where responsibility sits. It is where in the process you need to be paying attention.

In Joule Studio, this translates into two things you define when you build an agent: guardrails and human-in-the-loop checkpoints. Guardrails define the boundaries: what data the agent can access, what actions it can take on its own, what it must stop and ask a human before doing. Human-in-the-loop checkpoints are the moments you deliberately build into the workflow where a person reviews, approves, and owns the decision before the agent executes.

Think about a regulated workflow, the kind where every action needs a formal sign-off. The agent does the research, prepares the documentation, checks it against the relevant standards. The human reads it, approves it, and their name goes on it. The audit trail records the person, not the agent.

When I explained it this way, the follow-up question changed. It stopped being “who is responsible?” and became “where do I put my checkpoint?” That is the shift from fear to design thinking. And once a room makes that shift, you can actually start building something.

The insight: The biggest barrier to agentic AI adoption in enterprise is not technology. It is accountability and trust. Organizations need governance frameworks before they need agents.

Point 3 : Token efficiency is the new performance tuning, and SAP developers already know how to think about it

Performance tuning was a critical discipline in any SAP implementation. I remember spending hours running traces, analysing execution plans, hunting down the one SELECT statement that was dragging an entire report to its knees. Every unnecessary field in a query, every missing index, every unbounded loop. It all had a cost, and experienced developers felt that cost instinctively. They designed with resource efficiency in mind without even thinking about it.

That instinct maps directly to one of the most important concepts in agentic AI development: token efficiency. Every prompt you write, every agent instruction you define, every skill you compose : these consume tokens. And tokens cost time, money, and performance. Writing prompts and agent instructions that are lean and purposeful is not just good practice, it is the difference between an agent that scales and one that breaks under load.

In the sessions we introduced the CRISP framework as a structured way to think about prompting, making sure every prompt has clear Context, a defined Role, precise Instructions, the right Specifics, and a stated Purpose. We also spent time on context engineering: understanding what information you actually need to pass to the agent at each step, and what you can leave out. Just like you would not SELECT * when you only need three fields, you do not flood an agent with context it does not need to complete its task.

What struck me every time was how quickly experienced SAP developers picked this up. They have been thinking about resource efficiency for decades. An ABAP developer who spent years optimising SELECT statements already has the mental model :  they just need to point it at a different problem. The mindset is the same: be precise, be intentional, and never ask the system for more than you need. SAP's existing talent base is far more ready for this than they think.

The insight: Token efficiency is not just a cost concern; it is a design discipline. And SAP's developer community already has the muscle memory for it.

Point 4 :  MCP tools changed how I think about integration and how I explain it to customers

Model Context Protocol is one of the hardest concepts to land in the sessions. When I first encountered it I sat with it for days. I read it, re-read it, tried to explain it to myself, and still felt like something was slightly out of focus. It was only when I had to stand in front of a room and teach it, five times to five different audiences, that the right way to explain it finally emerged.

The analogy that worked: “An MCP tool is like a well-defined API contract, but instead of a developer calling it, an AI agent decides when to call it and what to pass.”

That single sentence unlocked it for most people. But what made it land differently in each room was knowing the audience before I walked in. Before any session started, I made a point of understanding the background of the people in the room. If the group was from an integration-heavy background, I connected MCP to API Management and event-driven architecture, patterns they already knew and trusted. If they were from an application development background, I leaned on the contract analogy. The concept was the same. The entry point changed.

What I came to realise through this process is that MCP is not a new idea. It is integration thinking with an AI decision layer on top. The principles SAP practitioners already understand, well-defined interfaces, clear input and output contracts, separation of concerns, all apply. The one thing that is genuinely new is who initiates the call. It used to be a developer. Now it is an agent. That is a significant shift in how you design, but it is not a shift that requires you to throw away twenty years of integration knowledge. You build on it.

The insight: You do not need to unlearn integration knowledge to understand MCPs. You need to reframe it: the caller is now an AI agent, not a human developer.

Point 5 : Teaching something is the fastest way to learn it, especially when 25 people are asking questions you have not thought of

I want to be honest about something. When I started facilitating in August, I was still consolidating my own understanding. I had attended sessions, I had prepared, but there were corners of this material I had not fully explored. I knew that going in.

What I did not expect was how thoroughly the participants would explore those corners for me.

After every session my mind was buzzing. Not from the content I delivered, but from the questions they asked. Questions I had not anticipated, angles I had not considered, connections to their specific domains that I had never thought to make. I would come home, open my laptop, and sit with those questions until I had proper answers. Before each new session I went back through the material with fresh eyes, looking for what I might have missed, preparing for the version of the question I had not heard yet. By the third session, the preparation itself had become a form of learning. By the fifth, I was not just delivering content anymore. The discussions in the room were shaping it.

In some ways I learned more from those five sessions than I did from all the material I studied before them. The participants brought their real problems, their real scepticism, and their real curiosity. That is not something you can prepare for. It is something you learn to welcome.

The insight: If you want to accelerate your learning in any technology, find a way to teach it. The learners will do the rest.

I started 2026 as an AI learner. By the middle of the year I had shifted focus entirely to agentic AI. I am ending it as a practitioner, a trainer, and someone with more questions than when I started, which I have learned to take as a good sign. There are more sessions ahead and more to learn.

If you are building or exploring agentic AI with SAP and want to compare notes, reach out. The conversation is always more interesting than the slides.

Source link

Leave a Reply

Your email address will not be published. Required fields are marked *

Chat with us on WhatsApp!