SAP Fachkonzept in 28 Minuten: 5 KI-Agenten ersetzen den Beratungsprozess

SAP-Projekte starten fast immer gleich: Jemand kommt aus einem Meeting, hat handschriftliche Notizen, und irgendwann — Wochen später — steht ein Fachkonzept. In diesem Artikel zeige ich, wie 5 KI-Agenten diesen Prozess in 28 Minuten erledigen. Nicht perfekt, aber 80% der Arbeit. Der Rest bleibt beim Menschen.

Das Problem

Wer SAP-Projekte kennt, kennt den Weg von der Anforderung zur Spezifikation:

1. Meeting mit dem Fachbereich (1 Tag)
2. Anforderungen strukturieren (2–3 Tage)
3. SAP-Objekte zuordnen — Tabellen, TCodes, BAPIs (2–3 Tage)
4. Fachkonzept schreiben (3–5 Tage)
5. Technische Spezifikation erstellen (2–3 Tage)
6. QA-Review und Überarbeitung (1–2 Tage)

Das sind 2–3 Wochen Beraterzeit. Bei Tagessätzen von 1.500–2.500 € schnell fünfstellig.

Die Frage war: Wie viel davon ist Routinearbeit, die sich automatisieren lässt?

Die Idee: Ein AI-Beraterteam

Statt einem einzelnen AI-Prompt baue ich ein Team aus 5 spezialisierten Agenten. Jeder hat eine klare Rolle — wie in einem echten SAP-Projektteam:

┌─────────────────────────────────────────────────────────┐
│                 Claude Code Orchestrator                  │
│              (koordiniert alle 5 Agenten)                │
└──────────┬──────┬──────┬──────┬──────┬──────────────────┘
           │      │      │      │      │
           ▼      ▼      ▼      ▼      ▼
        ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐
        │ 01 │ │ 02 │ │ 03 │ │ 04 │ │ 05 │
        └────┘ └────┘ └────┘ └────┘ └────┘
        Req.   SAP    Func.  ABAP    QA
        Extr.  Mapper Spec   Advisor Review

Die Agenten arbeiten sequenziell — jeder liest den Output des vorherigen Agenten und baut darauf auf. Genau wie in einem echten Projekt.

Projektstruktur

Das Setup ist bewusst einfach gehalten:

sap-ai-team/
├── knowledge_base/          ← SAP-Referenzdaten (das "Beraterwissen")
│   ├── sap_modules.json     ← 8 Module (MM, SD, FI, CO, PP, WM, QM, HCM)
│   ├── sap_tables.json      ← 20 Tabellen mit Feldern
│   ├── sap_tcodes.json      ← 25 Transaktionscodes
│   ├── sap_bapis.json       ← 14 BAPIs und Funktionsbausteine
│   └── sap_glossary.json    ← 20 SAP-Begriffe
├── workspace/               ← Agenten schreiben hier ihre Ergebnisse
├── doc_generator/           ← Python-Script für Word-Export
│   └── docx_builder.py
├── output/                  ← Fertiges Word-Dokument
├── examples/                ← Beispiel-Input
│   └── sample_requirements.txt
└── CLAUDE.md                ← Projektkontext für Claude Code

Die Knowledge Base

Das ist das “Beraterwissen” als JSON. Keine KI-Magie — einfach strukturierte SAP-Referenzdaten, die die Agenten als Grundlage nutzen:

sap_modules.json — SAP-Module mit Prozessen und Abhängigkeiten:

{
  "code": "MM",
  "name": "Materials Management",
  "description": "Handles procurement, purchasing, inventory management...",
  "key_processes": ["Purchase Requisition", "Purchase Order", "Goods Receipt", ...],
  "related_modules": ["FI", "CO", "PP", "WM", "QM"]
}

sap_tables.json — Tabellen mit wichtigen Feldern:

{"table": "EKKO", "description": "Purchasing Document Header",
 "important_fields": ["EBELN", "BUKRS", "BSTYP", "BSART", "LIFNR", "EKORG", "EKGRP"],
 "module": "MM"}

sap_tcodes.json — Transaktionscodes mit Use Cases:

{"tcode": "ME21N", "description": "Create Purchase Order",
 "module": "MM", "use_case": "Create new purchase orders with line items, pricing..."}

sap_bapis.json — BAPIs für programmatische Integration:

{"name": "BAPI_PO_CREATE1", "description": "Create Purchase Order via BAPI",
 "module": "MM", "key_parameters": ["POHEADER", "POHEADERX", "POITEM", ...]}

sap_glossary.json — SAP-Terminologie:

{"term": "Release Strategy",
 "definition": "Configuration that defines approval workflow for purchasing documents...",
 "sap_field": "FRGSX"}

In einem echten Setup würdest du diese Daten aus dem SAP-System selbst ziehen — z.B. über einen MCP-Connector, der SE11-Metadaten live abfragt. Für den Proof of Concept reichen die statischen JSON-Dateien.

Die CLAUDE.md

Die CLAUDE.md ist der Projektkontext, den Claude Code bei jedem Start liest. Hier definierst du, wie die Agenten kommunizieren:

# SAP Spec Agent — Project Context

## How Agents Communicate
- Agents work sequentially: 1 → 2 → 3 → 4 → 5
- Each agent reads the previous agent's output from workspace/
- File naming convention:
  - Agent 1 writes: workspace/01_requirements.json
  - Agent 2 reads 01, writes: workspace/02_sap_mapping.json
  - Agent 3 reads 01 + 02, writes: workspace/03_functional_spec.json
  - Agent 4 reads 02 + 03, writes: workspace/04_technical_spec.json
  - Agent 5 reads ALL (01-04), writes: workspace/05_qa_review.json

## SAP Knowledge Base
Agents 2, 3, and 4 MUST read knowledge_base/ files to inform their work.

Der Input: Eine echte Meetingnotiz

Hier der Realitätscheck. Das ist kein bereinigtes Template — es ist eine typische Meetingnotiz, wie sie in SAP-Projekten täglich anfallen:

hey so we discussed in the meeting yesterday with Thomas from purchasing and
Maria from finance. basically what we need is:

the current purchase order approval process is too slow. right now everything
over 5000 EUR needs to be approved by the department head but it takes forever
because they have to go into SAP and check each PO manually.

what we want:
- automatic approval for POs under 1000 EUR
- POs between 1000-5000 EUR should go to cost center manager
- POs over 5000 EUR should go to department head AND finance controller
- if any PO has items from a "critical" material group it should always
  go to department head regardless of amount
- we need email notifications when a PO is waiting for approval
- approvers should be able to approve from their phone somehow
- we also want a report showing all POs pending approval and how long
  they've been waiting — Thomas wants this weekly
- oh and Maria mentioned that the budget check should happen BEFORE the
  approval workflow starts, not after like it does now
- also can we get the vendor rating somehow shown on the PO approval screen?

timeline is Q2 this year. thomas says it's urgent.

Informell, unstrukturiert, mit offenen Fragen. Genau das, was ein Berater als Input bekommt.

Die 5 Agenten im Detail

Agent 1: Requirements Extractor

Rolle: Senior SAP Business Analyst

Aufgabe: Lies die chaotische Meetingnotiz und extrahiere strukturierte Anforderungen.

Prompt (gekürzt):

You are a senior SAP business analyst. Read examples/sample_requirements.txt
and extract structured business requirements. For each requirement create:
ID (REQ-001 format), title, detailed description, business process area,
priority (must/should/could), open questions, and acceptance criteria.
Also identify: project_context, assumptions, and out_of_scope items.
Write valid JSON to workspace/01_requirements.json.

Output: workspace/01_requirements.json

{
  "project_name": "Purchase Order Approval Workflow Redesign",
  "stakeholders": [
    {"name": "Thomas", "role": "Key User", "department": "Purchasing"},
    {"name": "Maria", "role": "Key User", "department": "Finance"}
  ],
  "requirements": [
    {
      "id": "REQ-001",
      "title": "Automatic Approval for Low-Value POs (< 1,000 EUR)",
      "priority": "must",
      "acceptance_criteria": [
        "POs with total net value < 1,000 EUR are auto-approved without manual intervention",
        "Auto-approval is logged for audit trail"
      ]
    },
    ...
  ],
  "assumptions": [
    "SAP ECC 6.0 or S/4HANA is in use",
    "Organizational hierarchy is maintained in HR-OM",
    ...
  ],
  "open_questions": [
    "Which specific material groups are classified as critical?",
    "Should approval be parallel or sequential for dual-approval?",
    ...
  ]
}

9 strukturierte Anforderungen, 9 Annahmen, 11 offene Fragen — aus einer informellen Meetingnotiz.

Agent 2: SAP Mapper

Rolle: Senior SAP Functional Consultant (15+ Jahre Erfahrung)

Aufgabe: Ordne jede Anforderung konkreten SAP-Objekten zu. Keine allgemeinen Vorschläge — echte Tabellen, echte TCodes, echte BAPIs.

Was der Agent liest:

• workspace/01_requirements.json
• Alle 5 Knowledge-Base-Dateien

Output-Beispiel für REQ-001 (Auto-Approval):

{
  "requirement_id": "REQ-001",
  "module": "MM",
  "tcodes": [
    {"tcode": "ME28", "description": "Release Purchase Order", "usage": "Manual release fallback"},
    {"tcode": "ME21N", "description": "Create Purchase Order", "usage": "PO creation triggering auto-release"}
  ],
  "tables": [
    {"table": "EKKO", "description": "Purchasing Document Header", "purpose": "Read PO total value (GNETWR)"},
    {"table": "T16FS", "description": "Release Strategy", "purpose": "Release strategy configuration"}
  ],
  "bapis": [
    {"name": "BAPI_PO_RELEASE", "use_case": "Programmatically approve POs under threshold"}
  ],
  "implementation_approach": "configuration + custom_abap",
  "enhancement_points": [
    {"type": "BADI", "name": "ME_PROCESS_PO_CUST", "description": "Central PO processing hook"}
  ],
  "complexity": "medium"
}

Der Agent hat für alle 9 Anforderungen SAP-Objekte zugeordnet — plus 7 Authorization Objects, 7 Integrationspunkte und 12 Testing-Überlegungen (inklusive Grenzwerttests bei 999,99 EUR und 5.000,01 EUR).

Agent 3: Functional Spec Writer

Rolle: Expert SAP Specification Author

Aufgabe: Schreibe ein vollständiges Fachkonzept mit AS-IS/TO-BE Prozessbeschreibung, Feldtabellen, Geschäftsregeln und Testfällen.

Was der Agent liest:

• workspace/01_requirements.json
• workspace/02_sap_mapping.json
• knowledge_base/sap_tables.json

Highlights aus dem Output:

AS-IS Prozess — Beschreibt den aktuellen manuellen Freigabeprozess mit allen Schwachstellen.

TO-BE Prozess — 13-stufiger Ablauf vom PO-Anlegen bis zur Freigabe, mit allen Pfaden (Auto-Approval, Single, Dual, Critical Material Override).

Geschäftsregeln — 53 dokumentierte Regeln, darunter:

Feldmapping — Echte SAP-Felder mit Tabelle, Datentyp und Validierung:

28 Testfälle — inklusive Grenzwerttests:

Agent 4: ABAP Technical Advisor

Rolle: Senior ABAP Developer & Technical Architect

Aufgabe: Erstelle eine technische Spezifikation mit Entwicklungsobjekten, Pseudo-ABAP-Code und Aufwandsschätzung.

Was der Agent liest:

• workspace/02_sap_mapping.json
• workspace/03_functional_spec.json
• knowledge_base/sap_bapis.json

15 Entwicklungsobjekte — alle mit Z_-Prefix und Pseudo-Code:

METHOD if_me_process_po_cust~process_header.
  DATA: lv_total TYPE netwr,
        lv_eur   TYPE netwr.

  * Get PO total value
  lv_total = im_header->get_data( )-gnetwr.

  * Convert to EUR if needed
  IF im_header->get_data( )-waers <> 'EUR'.
    CALL FUNCTION 'CONVERT_TO_LOCAL_CURRENCY'
      EXPORTING
        date             = sy-datum
        foreign_amount   = lv_total
        foreign_currency = im_header->get_data( )-waers
        local_currency   = 'EUR'
        type_of_rate     = 'M'
      IMPORTING
        local_amount     = lv_eur.
  ELSE.
    lv_eur = lv_total.
  ENDIF.

  * Auto-release for POs under 1000 EUR
  IF lv_eur < 1000.
    CALL FUNCTION 'BAPI_PO_RELEASE'
      EXPORTING
        purchaseorder = im_header->get_data( )-ebeln
        po_rel_code   = 'SA'.
    CALL FUNCTION 'BAPI_TRANSACTION_COMMIT'
      EXPORTING wait = 'X'.
  ENDIF.
ENDMETHOD.

Aufwandsschätzung:

Aufschlüsselung: 46 Tage Entwicklung + 16 Tage Unit-Testing + 5 Tage Dokumentation.

Agent 5: QA Reviewer

Rolle: Senior QA & Compliance Reviewer

Aufgabe: Prüfe ALLE 4 vorherigen Dokumente auf Vollständigkeit, Konsistenz, Risiken und Lücken.

Was der Agent liest: Alle 4 workspace-Dateien.

Und hier wird es spannend. Der QA-Agent ist kein Rubber Stamp:

Ergebnis: Amber — 82% — Nicht freigabereif

┌─────────────────────────────────┐
│     QA-Ergebnis: AMBER 82%     │
│                                 │
│  ● 2 Kritisch                   │
│  ● 6 Major                      │
│  ● 6 Minor                      │
│  ● 3 Hinweise                   │
│                                 │
│  Empfehlung: Needs Rework       │
└─────────────────────────────────┘

Die kritischen Findings:

QA-F-001 (Kritisch): Die Liste der kritischen Warengruppen fehlt. Ohne sie kann das System nicht konfiguriert werden. Der Agent empfiehlt: Workshop innerhalb einer Woche mit Thomas einberufen.

QA-F-005 (Major): Der SAP Mapper (Agent 2) verwendet EKKO-NETWR als Header-Feld — das existiert nicht im SAP-Standard. Korrekt ist EKKO-GNETWR. Die Agenten 3 und 4 verwenden es richtig, aber die Inkonsistenz in Dokument 2 könnte Entwickler verwirren.

QA-F-006 (Major): Die WBS-Budgetprüfung ist im Pseudo-Code nur als Platzhalter implementiert. POs mit WBS-Kontierung würden die Budgetprüfung stillschweigend überspringen.

QA-F-015 (Hinweis): Die 67 Tage Aufwand sind reine Entwicklungszeit. Integrationstests, UAT, Performance-Tests und Cutover fehlen. Realistisch: 95–110 Tage.

Das ist der überzeugendste Teil des gesamten Projekts: Die KI überprüft sich selbst und findet echte Fehler. Kein SAP-Experte musste draufschauen, damit der NETWR/GNETWR-Fehler auffällt.

Den ganzen Prozess starten

Den Prompt jedes Mal neu eintippen? Muss nicht sein. Claude Code hat Custom Agents und Slash-Commands — damit wird die ganze Pipeline zu einem einzigen Befehl.

Die Struktur:

sap-ai-team/
└── .claude/
    ├── agents/
    │   ├── sap-requirements-extractor.md
    │   ├── sap-mapper.md
    │   ├── sap-spec-writer.md
    │   ├── sap-abap-advisor.md
    │   └── sap-qa-reviewer.md
    └── commands/
        └── sap-fachkonzept.md

Jede Datei unter agents/ definiert einen Agenten. Der Slash-Command in commands/ ruft sie der Reihe nach auf.

Die 5 Agent-Definitionen

.claude/agents/sap-requirements-extractor.md

---
name: sap-requirements-extractor
description: Extracts structured requirements from messy meeting notes
---

You are a senior SAP business analyst.
Read examples/sample_requirements.txt and extract structured requirements.
For each requirement: ID (REQ-001), title, description, business process area,
priority (must/should/could), open questions, acceptance criteria.
Also capture: project_context, assumptions, out_of_scope.
Write valid JSON to workspace/01_requirements.json.

.claude/agents/sap-mapper.md

---
name: sap-mapper
description: Maps requirements to concrete SAP objects
---

You are a senior SAP functional consultant with 15+ years experience.
Read workspace/01_requirements.json and all files in knowledge_base/.
For each requirement map: SAP module, TCodes, tables, BAPIs, enhancement points,
authorization objects, integration touchpoints, complexity (low/medium/high).
No generic suggestions — use the real objects from the knowledge base.
Write valid JSON to workspace/02_sap_mapping.json.

.claude/agents/sap-spec-writer.md

---
name: sap-spec-writer
description: Writes a complete SAP functional specification
---

You are an expert SAP functional specification writer.
Read workspace/01_requirements.json, workspace/02_sap_mapping.json,
and knowledge_base/sap_tables.json.
Write a complete functional spec with: AS-IS process, TO-BE process,
business rules (with IDs like BR-001), field mapping table with SAP field names,
data types and validation rules, test cases including edge cases.
Write valid JSON to workspace/03_functional_spec.json.

.claude/agents/sap-abap-advisor.md

---
name: sap-abap-advisor
description: Creates ABAP technical specification with effort estimate
---

You are a senior ABAP developer and technical architect.
Read workspace/02_sap_mapping.json, workspace/03_functional_spec.json,
and knowledge_base/sap_bapis.json.
Create a technical spec with: all development objects (Z_ prefix),
pseudo-ABAP code for key logic, effort estimate per object in days
(split: development / unit test / documentation).
Write valid JSON to workspace/04_technical_spec.json.

.claude/agents/sap-qa-reviewer.md

---
name: sap-qa-reviewer
description: QA review across all 4 previous agent outputs
---

You are a senior SAP QA and compliance reviewer.
Read ALL files in workspace/ (01 through 04).
Check for: completeness, consistency between documents, missing requirements,
incorrect SAP field names or table references, unrealistic estimates,
compliance gaps (authorization, audit trail, segregation of duties).
Rate each finding: Critical / Major / Minor / Note.
Give an overall score (0–100%) and a release recommendation (Green/Amber/Red).
Write valid JSON to workspace/05_qa_review.json.

Der Slash-Command

.claude/commands/sap-fachkonzept.md

Run the SAP spec agent pipeline sequentially:

1. Use agent sap-requirements-extractor
2. Use agent sap-mapper
3. Use agent sap-spec-writer
4. Use agent sap-abap-advisor
5. Use agent sap-qa-reviewer

Each agent reads the previous outputs from workspace/ before writing its own.
All agents working with SAP objects must read the relevant knowledge_base/ files.

Ausführen

Meetingnotiz in examples/sample_requirements.txt ablegen, dann in Claude Code:

/sap-fachkonzept

Das war’s. Claude Code startet alle 5 Agenten nacheinander, die Datei-Übergaben laufen automatisch. Nach ~28 Minuten liegen die JSON-Outputs im workspace/-Ordner.

Das Word-Dokument generieren

Der letzte Schritt: Aus den 5 JSON-Dateien ein professionelles Word-Dokument erstellen.

source .venv/bin/activate
python doc_generator/docx_builder.py

============================================================
SAP Functional Specification — Document Generator
============================================================

Loading workspace files...
Loading knowledge base glossary...

Building document...
  Section 1 — Business Overview
  Section 2 — Requirements
  Section 3 — SAP Object Mapping
  Section 4 — Functional Specification
  Section 5 — Technical Specification
  Section 6 — Test Cases
  Section 7 — QA Review
  Appendix — SAP Glossary

Document saved to: output/SAP_Functional_Spec_20260226_160649.docx
============================================================

Das Ergebnis: 83 Seiten, professionell formatiert, mit gestalteten Tabellen, SAP-Glossar im Anhang und Monospace-Font für ABAP-Code. Bereit für die Kundenabstimmung.

Tipp: Den Python-Code kannst du dir sparen. Es gibt MCP-Connectoren für Claude Code, die Word-Dokumente direkt erzeugen — z.B. den Office-Word-MCP-Server oder mcp-pandoc. Einmal eingerichtet, kann ein sechster Agent den Spec-Output direkt als .docx schreiben, ohne externes Script.

Die Ergebnisse

Was als Nächstes möglich wäre

Das Setup hier ist bewusst einfach. Ohne externe Anbindungen, ohne Custom Skills. Die nächsten Ausbaustufen:

Eigene Agent Skills pro Kundenkontext:

Für jeden SAP-Kunden eigene Agent-Definitionen mit kundenspezifischen Namenskonventionen, Z-Objektpräfixen und Customizing-Logik. Statt eines generischen /sap-fachkonzept dann z.B. /sap-fachkonzept-kunde-xyz.

MCP-Connectoren:

• SAP-System direkt anbinden — Tabellen-Metadaten live aus SE11
• Jira/Azure DevOps — Anforderungen direkt aus Tickets
• Confluence/SharePoint — Spec automatisch veröffentlichen

Eigene Knowledge Base:

• SAP Help Portal als RAG-Quelle statt statischer JSON-Dateien
• OSS Notes für bekannte Probleme und Lösungen
• Firmenspezifische SAP-Best-Practices

Fazit

Ersetzt KI den SAP-Berater? Nein. Aber sie automatisiert den Großteil der wiederkehrenden Arbeit — in Minuten statt Tagen.

Die 5 Agenten liefern 80% des Fachkonzepts. Den Rest — Stakeholder-Entscheidungen, die feinen Konfigurationsdetails, die eine Einstellung in SPRO, die alles zum Laufen bringt — das bleibt beim Menschen.

Der spannendste Teil: Der QA-Agent, der die eigene Pipeline kritisiert und echte Fehler findet. Das ist kein Rubber Stamp. Das ist ein System, das sich selbst hinterfragt.

28 Minuten. 83 Seiten. 82% QA-Score. Nicht perfekt — aber ein Vorsprung, der sich nicht ignorieren lässt.

Du möchtest ein Multi-Agenten-System für SAP-Projekte in deinem Unternehmen einsetzen? Dann schreib mir einfach auf LinkedIn oder buche direkt einen kostenlosen Call.