AI Core Hub is the control room for AI agents that work where your people already work: inside SAP. Each team configures its own agents, gives them skills and its own knowledge, and docks a chat assistant right into any transaction — one that reads the screen in front of the user, answers from your own documents, and pulls only the data they're allowed to see.
A short look at the control room and the agent that docks into the screen.
Business users spend their day inside dense SAP screens. The moment they're stuck — what does this field mean, what's the stock of this material, why did this error appear — the answer lives somewhere else: a manual, a colleague, a ticket queue, another transaction. So they alt-tab, they wait, or they guess.
And every team's hard-won knowledge — how their product works, how their process runs, how to fix the common cases — sits in documents nobody is reading at the exact moment it's needed.
The intelligence and the work happen in two different places. AI Core Hub puts them in the same place.
The Hub is the control room. It doesn't run the AI itself — it decides what AI each team is allowed to run, and how. And it's organised exactly the way your company already is.
Every team that owns a product or area gets its own space — its own agents, knowledge and keys, without touching anyone else's.
A single SAP transaction or a whole business area — wherever a group of people actually do their job. Defined once, then built around.
A name, an identity, an instruction, and one job. One answers business questions; another handles technical detail. Deliberately focused.
Concrete actions inside SAP: read the current screen, check stock, explain a field, run a safe query. The team picks exactly which skills each agent may use.
The team loads its documents — manuals, specs, process guides, past tickets — and the agent answers from them, grounded in your material.
The AI provider keys, set once at company, team or user level and resolved automatically. No secrets scattered around, no per-person setup.
The configuration app where each team sets up its zones, agents, skills and knowledge — running now as a working prototype.
Assistants around the SHIELD authorization framework.
Master-data helpers for the MDM team.
Change-document / event explainers.
| Name | Model | Temp | Skills | State |
|---|---|---|---|---|
| Technical Expert default | AZURE_GPT4O | 0.0 | SQL | active |
| Business Helper | AZURE_GPT4O | 0.3 | — | active |
| Title | Type | Chunks | Indexed |
|---|---|---|---|
| SHIELD SELECT cheat sheet | MARKDOWN | 24 | indexed |
| ZCL_SHIELD_CHECK_OSQL usage | CODE | 11 | indexed |
| Auth object catalogue (draft) | TEXT | 7 | pending |
| Skill | Class | Scope | State |
|---|---|---|---|
| SQL | ZCL_AICORE_SKILL_SQL | global | active |
| SCREEN_FIELDS | ZCL_AICORE_SKILL_SCREEN_FIELDS | global · GUI | active |
| AUTH_LOOKUP | ZCL_SHIELD_AI_AUTH_LOOKUP | zone | active |
| SQL (override) | ZCL_AICORE_SKILL_SQL | app · max_rows 50 | active |
| CD_READ | ZCL_CENT_AI_CD_READ | app | inactive |
The agent appears as a panel docked to the side of the transaction the user is already in — left or right, always there, never blocking the work. Not a popup. A teammate, beside you.
Because it runs inside the user's own session, the agent can see the screen in front of them. The user just points at what they're looking at — “what's the stock of this material?” — and the agent already knows which material, because it's reading the same screen.
The team built a precise skill — say a stock check — so the agent does it the right way, every time.
A safe, read-only query against the tables the user is allowed to see — enforced by SAP's own authorisations. Nobody sees data they don't already have rights to.
For an application the team owns, skills can guide the user through changing data — validated, the way the team designed it.
Think of it as a librarian with a perfect memory. The team hands it everything written about their area — manuals, specifications, process notes, resolved tickets. AI Core breaks each document into small passages and files them by meaning, not just keywords.
When someone asks a question, it instantly pulls the handful of passages that actually answer it and lets the agent reply in plain language — grounded in your material, not the open internet. Add a new document and the agent is smarter the next minute, with nothing to retrain.
This is the industry-standard RAG pattern — retrieval-augmented generation — the modern, trusted way to give an AI private knowledge without it ever inventing answers.
PDFs and Office documents, specifications, manuals, process guides, configuration notes — anything a team would otherwise explain by hand.
Past support tickets and how they were resolved. The agent learns your real fixes, not generic advice.
Replies are tied to the passages that justify them — so the agent stays honest and you can check the source.
Not every agent waits to be asked. The same building blocks — persona, skills, knowledge — power agents that run a process on their own.
Point an agent at a ServiceNow incident queue — the world's most-used service desk. It watches everything coming in, understands each ticket against the team's loaded knowledge, and acts: drafts a resolution, suggests the next step, or flags what genuinely needs a human.
A tireless first responder that already knows your application — because the responsible team taught it, once, in the Hub.
| Incident | Subject | Status |
|---|---|---|
| INC0042918 | Stock mismatch | AI drafted |
| INC0042920 | MRP run failed | AI drafted |
| INC0042925 | Field meaning? | AI answered |
| INC0042931 | Pricing exception | Needs human |
| INC0042933 | New material setup | New |
Stand up agents for your area, load your knowledge, and decide exactly what they can do — no central bottleneck.
Ask in plain language about the screen in front of you and get an answer from your own data in seconds.
Teach an agent once; it answers the same questions for everyone, day and night, citing your material.
Let an agent watch the queue, draft resolutions, and surface only what truly needs a person.
Configure a zone, build an agent, load your knowledge, and drop it into the transaction your people already use. The intelligence finally lives where the work does.