SAP + Cursor · ABAP and Fiori on S/4HANA
A plain-English change request becomes an FSCM-aware ABAP extension, a Fiori warning, ABAP Unit tests, and a staged transport. Cursor grounds itself in your real SAP data model through an MCP add-on, so the change fits your system instead of guessing at it. You review one PR.
The same MCP, rules, hooks, and subagents close the copy-paste loop between the SAP IDE and Cursor. Every primitive is a real file your team can audit in .cursor/.
Build against the real system, not guesses
The agent reads your actual DDIC, CDS views, and services through the SAP MCP before it writes a line. Generated ABAP and Fiori target the real contract, so the change set you review already fits your S/4HANA system.
No copy-paste between ADT and Cursor
MCP reads and writes SAP directly, rules carry your ABAP standards into every session, and hooks pretty-print, run ATC, and run ABAP Unit. You stop shuttling source and error logs between Eclipse and a chat window.
You own release
The agent stages to QAS, opens a PR, and updates the change request. It never activates against production and never releases a transport to PRD. A human approves the PR and promotes.
Guardrails every build clears
Consultant workflow · before and after
Same SAP change request, same human approval. Cursor compresses the manual tool-hopping into one grounded, reviewable delivery pack.
Stage
Scope
Workshop notes + SAP docs
Read the change, search SAP Help, ask an SME which objects matter, and rewrite the ask as a technical spec.
Cursor intake + rules
Cursor turns the change into a constrained build plan using your SAP delivery standards and clean-core rules.
Stage
Landscape MRI
ADT, SE11, CDS browser, ATC
Copy DDIC, CDS, where-used, and ATC findings out of SAP tools to build enough context for safe design.
SAP MCP evidence
MCP reads the actual DDIC, CDS, ABAP source, ATC findings, and transport context without copy-paste.
Stage
Build
ADT + BAS/Fiori + terminal
Write ABAP, Fiori, tests, and service changes in separate tools, then reconcile object names by hand.
ABAP + Fiori subagents
Specialists draft the ABAP extension, Fiori warning, ABAP Unit, and transport object list in parallel.
Stage
Review
ATC, ABAP Unit, GitHub
Run ATC, copy failing logs into the assistant, fix formatting, and assemble evidence for review.
Hooks + Codex gate
Hooks pretty-print and verify; Codex reviews clean-core, contract, coverage, and transport completeness.
Stage
Client handoff
CTS, GitHub, ServiceNow
Package the transport, write the PR, update the change record, and prepare CAB notes by hand.
PR + CAB pack
Cursor links the PR, QAS transport, tests, and ServiceNow change into one reviewable delivery pack.
Today you copy ABAP and DDIC out of SAP GUI or ADT, paste into an assistant, copy the suggestion back, activate, run ATC, and copy the error log back again. Each Cursor primitive replaces one manual round-trip, wired with real files you can read in .cursor/.
MCP
Manual round-trip
Copy ABAP / DDIC out of ADT, paste into a chat, copy the suggestion back, paste into ADT, activate by hand.
With Cursor
The SAP MCP reads source + DDIC + CDS and writes + activates objects in the allowed DEV client. No copy out, no paste back.
Rules
Manual round-trip
Re-explain ABAP naming, clean-core, and transport standards in every new chat.
With Cursor
.cursor/rules/sap-*.mdc inject the standards every session, version-controlled in the repo.
Hooks
Manual round-trip
Hand-format generated ABAP, run ATC, then copy red ABAP Unit output back into the assistant.
With Cursor
afterFileEdit pretty-prints + queues ATC; stop runs ABAP Unit and hands failures back so the agent self-repairs.
Subagents
Manual round-trip
Shuttle intermediate findings between separate chats for backend, frontend, and transport work.
With Cursor
A planner dispatches the ABAP, Fiori, transport, and review subagents in parallel, each in its own context.
Cloud agents
Manual round-trip
Run the whole edit, activate, test, transport, and PR loop locally across Eclipse, a terminal, and a browser.
With Cursor
A Cloud Agent runs the reviewable-change loop on a VM that reaches SAP over Tailscale and opens a verified PR. You review, you do not shuttle.
Straight talk
stop loop run on your local IDE agent; the cloud agent uses afterFileEdit / beforeShellExecution plus the verified-PR handoff.cursor.com/agents and an on-prem S/4HANA is reached over Tailscale userspace networking.Reference config: docs/partner-demos/sap-cursor-config/
Beyond automation orchestration
The scripted demo is one motion. Here is the rest of what your team does with Cursor against an SAP estate.
Build + deploy
#1 · #4
Describe a feature and Cursor drafts the ABAP extension, Fiori UI changes, tests, and transport-ready artifacts through an MCP add-on. Backend plus modern UI, on-premise, with you reviewing the result before anything moves forward.
Grounded agents
#2 · #5
An MCP connection lets the agent query and act against S/4HANA and BTP services instead of you copy-pasting context back and forth. Generated code and automations are grounded in the actual data model and APIs, not guesses.
Operationalize
#1 · #2
Agents and Cloud Agents reach a community-built MCP server that exposes SAP APIs, RFCs, and ABAP modules. They read service definitions, prepare ABAP and frontend changes, activate in the allowed development client, and stage the transport. Cursor uses the open MCP standard, so the SAP connector is custom or community-built, which is also an SI opportunity.
Orchestrate
#3
Use Cursor alongside your existing SAP tooling, with agent orchestration across big Java and .NET repositories and side-by-side BTP services. The agent walks the codebase and the tools for you instead of you tab-switching across them.
Faster delivery
#4
Describe what you want and the agent scaffolds, edits, and tests across the whole project. You spend less time on repetitive setup and ship BTP extensions and side-by-side apps faster.
Modernize
#6
Agents read large, unfamiliar SAP, Java, and .NET codebases and help you refactor, document, and migrate them. You onboard onto messy legacy estates faster and get a safer path to modernize, without months of manual archaeology.
Every primitive below is a concrete file your team commits. The skills, subagents, and rules are real in .cursor/; the runtime config lives in docs/partner-demos/sap-cursor-config/.
Architecture
3 trigger surfaces
ServiceNow change · Slack /build · ChaRM transition
Cursor cloud agent
environment.json · SAP toolchain · Tailscale to S/4HANA
1 MCP · 4 subagents · 4 hooks
planner + ABAP/Fiori/transport/review, each scoped
sap-build
Turn a plain-English change request into an FSCM-aware ABAP extension + a Fiori warning + a staged transport + a PR, in one orchestrated run.
abap-engineer
Composer 2.5
fiori-engineer
Composer 2.5
transport-steward
Composer 2.5
abap-reviewer
Codex
Ground the change in the real SAP system, fix the contract, dispatch specialists, synthesize a transport-ready change set, open the PR. Never writes code itself.
.cursor/skills/sap-build-planner/SKILL.md
Write + activate the ABAP (class, function module, ABAP Unit) against the real DDIC through the SAP MCP. Never copy source through chat.
.cursor/agents/sap-abap-engineer.md
Write the Fiori elements / UI5 extension bound to the new CDS field. Keep the app upgrade-safe.
.cursor/agents/sap-fiori-engineer.md
Capture every object into one transport, verify completeness, stage to QAS. Never import to PRD.
.cursor/agents/sap-transport-steward.md
Review clean-core, contract safety, transport completeness, and ABAP Unit coverage before write-back. Blocks; does not patch.
.cursor/agents/abap-reviewer.md
Watch the agent ground in SAP, draft ABAP and Fiori, run ABAP Unit, stage a transport, and open a PR you approve.
Run the scripted demo