Automate SAP order-to-cash with multi-agent AI & Google Agent Development Kit (ADK)

Key Concepts

• SAP Order-to-Cash (O2C): The end-to-end business process of receiving and fulfilling customer orders.
• RPA (Robotic Process Automation): Legacy automation that mimics human UI interactions (clicking/typing), often fragile due to UI changes.
• MCP (Model Context Protocol): A standard that allows AI agents to interact with external data sources and tools.
• Google ADK (Agent Development Kit): A framework for building, orchestrating, and delegating tasks between AI agents.
• OData: The standard protocol used by SAP to expose APIs and endpoints.
• Gemini 1M Token Context Window: Enables agents to handle massive amounts of data and complex reasoning.
• Agent Delegation: The ability for a "root" agent to assign tasks to specialized sub-agents, mirroring organizational hierarchies.

---

1. The Problem: Limitations of Legacy Automation

Large organizations (oil, gas, automotive, healthcare) face significant operational costs due to repetitive tasks like the "Order-to-Cash" process (creating orders, checking inventory, shipping, and invoicing).

• The RPA Flaw: Traditional RPA is brittle. Because it relies on screen coordinates and UI elements, minor changes in resolution or interface design break the automation, requiring constant developer maintenance.

2. The Solution: MCP and Google ADK

The proposed architecture replaces UI-based automation with API-based interaction.

• OData & MCP: SAP exposes its massive library of APIs via OData. By using the OpenAPI MCP Generator CLI, developers can convert these API specifications into standardized MCP tools that AI agents can consume directly.
• Scalability: SAP modules (like Sales & Distribution or Material Management) contain hundreds of APIs. The ADK solves the complexity of managing these by allowing agents to act as orchestrators rather than just simple executors.

3. Methodology: Hierarchical Agent Teams

The framework replicates corporate structures by mapping roles to specific agents:

• Root Agent (Supervisor): Does not access tools directly; its sole purpose is to receive requests and delegate tasks to sub-agents.
• Sub-Agents (Specialists):
  • Inventory Specialist: Handles stock-related queries.
  • Sales Order Creator: Executes the creation of orders and items.
• Process Flow:
  1. Request: User submits a natural language request.
  2. Delegation: The Supervisor analyzes the request and assigns it to the appropriate specialist.
  3. Reasoning: Agents do not just pass parameters; they reason through the request (e.g., creating filters for SAP queries).
  4. Execution: Agents utilize MCP tools to interact with the SAP backend.
  5. Parallelization: As of ADK v1.1, agents can execute multiple tool calls in parallel (e.g., adding multiple items to a sales order simultaneously) to improve performance.

4. Real-World Application: Order Creation

The video demonstrates a practical scenario:

• Task: Create a sales order based on an existing template (Order #6319) with specific material quantities.
• Outcome: The agent team successfully created Order #6321. The system demonstrated "reasoning" by filtering SAP data to find the correct materials and calculating the total price ($208,000) across multiple items.

5. Key Arguments and Perspectives

• Organizational Mapping: The speaker argues that you shouldn't have to rethink business processes to automate them. Instead, you should map existing human roles and responsibilities to "Agent Teams."
• Efficiency: By moving from UI-based RPA to API-based agentic workflows, organizations reduce maintenance overhead and increase the reliability of their automation.
• Agent Autonomy: The use of Gemini’s large context window allows agents to handle complex, multi-step instructions without needing constant human intervention.

6. Synthesis and Conclusion

The integration of Google ADK and MCP provides a robust, scalable alternative to traditional RPA. By leveraging API specifications to generate toolsets, organizations can build "Agent Teams" that mirror their internal hierarchy. This approach not only automates repetitive, time-consuming tasks like SAP order processing but also allows for intelligent reasoning and parallel execution, ultimately freeing human employees to focus on higher-value work. The framework is highly modular, allowing developers to define specific prompts and tool access for each agent role.