Automate Balance Confirmation Workflows in Financial Accounting with a Custom Joule Agent

Before building the agent, it is important to understand the problem it must solve. This#describes the three types of balance confirmation request the Finance team handles, and the manual pain points the agent will eliminate.

Three types of balance confirmation request

Business partners submit balance confirmation requests through different channels, and the content of each request varies considerably. The Finance team at RaiLona typically encounters three distinct request types:

Current pain points

The manual handling of these three request types creates the following well-understood operational challenges:

• Tool-switching overhead - Finance staff must switch between communication channels, ERP transactions, and document editors to complete a single request.
• Time-consuming lookups - Manual lookup and comparison of open items is slow, particularly at period-end when request volumes peak.
• Inconsistent response letters - Drafting letters by hand introduces variability in tone, format, and legal language across responses.
• Fragmented audit trail - Tracking open requests and maintaining a complete audit trail requires additional manual effort outside the core workflow.
• Partner follow-up load - Delayed or incomplete responses prompt follow-up inquiries from business partners, adding to the team’s workload.

The agent you build in this tutorial eliminates all five pain points by automating ingestion, classification, reconciliation, and letter generation - with human review required only for discrepancy and dispute cases.

Select the solution type you want to create, in this case Agent, and describe what you want to build. Joule will take your intent and translate it into a product requirements and technical specifications and finally implement the solution

1. Open SAP Joule Work and navigate to Joule Studio by choosing Develop in the left navigation panel.

2. In the Solutions pane, select + New and choose the option to create an agent. The Create Agent dialog opens.

3. Complete the three fields in the dialog:

   • Solution: Select New Solution to create this agent as a standalone solution.
   • Name: Enter the following agent name:
     Code Copy

     Automated Processing of Balance Confirmations

   • Intent Statement: Enter the following statement in plain business language:
     Code Copy

     Please create an agent. The agent should automatically process incoming balance confirmation requests from business partners and generate
     appropriate, legally compliant response letters. The objective is to reduce processing time, minimize follow-up inquiries, and improve the
     quality and traceability of communication.

   • Keep the Quick Create option checked. This will skip answering clarifying questions and directly move towards solution building.

4. Select Create to proceed.

The most important input in the entire process is the intent statement. Frame it around the business outcome you want to achieve, not the technical steps. Joule Studio derives the full technical design from your stated intent. If the generated Idea Board does not accurately reflect your goal, return here and refine the statement before continuing.

5. After submitting the prompt, Joule Studio starts to enrich it with the context.

6. When the intent is processed and enriched with the enterprise context, you may interact refining the business goals and other questions if any best to your knowledge. If not done automaticaly, you can ask to proceed with next phases of the Intent Based Development workflow.

In the Requirements phase, Joule Studio generates a full Product Requirements Document (PRD). The PRD formally captures what needs to be built, why it is needed, and how the agent is expected to behave. It serves as the contractual record between the business intent and the technical build.

Product Purpose and Value Proposition

Product Objectives (in priority order)

1. Automate classification of incoming balance confirmation requests and reconciliation with SAP data.
2. Generate localized, legally compliant response letters without manual drafting.
3. Ensure full traceability and audit-readiness of all communications.

Automation Level and Agent Behaviour

The Balance Confirmation Agent operates at a hybrid automation level: it handles fully matching cases autonomously and routes discrepancy or dispute cases to a human before dispatching a response.

Autonomous actions (no human required):

• Ingest incoming requests from email or document upload
• Fetch open items, GL account line items, and balances from SAP S/4HANA
• Reconcile stated figures against live SAP data using the deterministic engine
• Dispatch response letters for fully matching confirmations

Human review required for:

• Cases where the discrepancy between stated and SAP figures exceeds the configured threshold
• Requests classified as dispute-indicated

LLM boundaries

Request classification and response letter generation are handled by an LLM via SAP Generative AI Hub. Balance reconciliation uses a deterministic rule-based engine. All SAP S/4HANA Cloud API access is strictly read-only, covering accounting documents, GL account line items, and business partner data.

Guardrails

Four operational guardrails are built into the agent:

1. No financial data is ever modified - all S/4HANA API calls are read-only.
2. Low-confidence classifications are automatically escalated to human review.
3. API unavailability triggers request queuing and a notification to the Finance team.
4. All outbound letters must pass template validation before dispatch.

The result you get from your experience may be different from this requirements example. Make sure, the requirements generated for your solution are meeting you expectation.

Once you have reviewed the PRD and confirmed it accurately reflects your requirements, you can start the next phase of the project if it’s not started automatically.

In the Specification phase, Joule Studio translates the PRD into a structured set of technical artifacts - the complete blueprint from which the agent will be built. You do not write any of these artifacts manually; they are generated entirely from the intent and requirements you approved.

The Specification view opens in Code mode. The left panel shows a file tree organized into two folders.

Architecture note: Unlike agents that bundle all SAP API access inside a single component, the Balance Confirmation Agent uses separate MCP servers for each SAP OData API it consumes. This is the standard pattern when an agent needs to call multiple distinct SAP APIs - each server wraps one API and exposes it to the agent in a structured, LLM-interpretable format.

** Example of the assets/ folder**

assets/
├── balance-confirmation-agent/          # Core agent: reconciliation logic, LLM prompts,
│                                        # classification, letter generation, routing rules
├── sap-s4-business-partner-mcp-server/  # MCP server: Business Partner API
│                                        # (business partner master data)
├── sap-s4-glaccountlineitem-mcp-server/ # MCP server: GL Account Line Items API
│                                        # (open items and line-level balance data)
└── sap-s4-oplacctgdocitemcube-server/   # MCP server: Accounting Documents API
                                         # (accounting document header and item data)

What is MCP? MCP stands for Model Context Protocol - the standardized communication layer that allows an AI agent to interact with external systems such as SAP S/4HANA in a structured and secure way. Each MCP server wraps an individual SAP OData API and exposes it to the agent in a format the LLM can interpret and invoke. The three MCP servers here give the agent access to everything it needs to perform a full balance reconciliation without any direct database access.

The specification/ folder

Select any file in the tree to inspect its contents in the right-hand panel. The entire specification is transparent and reviewable before any deployment is triggered.

Best practice: Review solution.yaml to confirm the OData API bindings point to your target SAP S/4HANA Cloud system and that the BTP destination names match your subaccount configuration.

In the Solution phase, Joule Studio executes the specification and generates the complete, runnable solution. The agent code, the three MCP server integrations, the reconciliation logic, and the letter generation components are all assembled from the blueprint defined in Phase 3. No manual development is required.

This phase is largely automated. Joule Studio:

1. Scaffolds the full Python agent and the three MCP server packages based on the assets/ tree.
2. Wires up the SAP OData API bindings defined in solution.yaml for each MCP server.
3. Configures the SAP Generative AI Hub connection for LLM-based classification and letter generation.
4. Implements the four operational guardrails defined in the PRD.
5. Instruments all agent actions with audit logging.

Wait for the solution generation to complete before proceeding to the Testing phase.

If Joule Studio reports any configuration warnings - for example, a missing OData API binding or an unresolvable BTP destination - resolve them in solution.yaml before continuing. A warning at this phase will propagate to test failures in Phase 5.

Evaluation scenarios for the Balance Confirmation Agent

Before the agent can be deployed, Joule Studio runs a full automated validation suite. The Testing phase shows a complete overview of all generated tests and their results. The Deploy button becomes active only after testing is complete.

Testing Overview for the Balance Confirmation Agent

The Validation by Artifact section confirms that the balance-confirmation-agent artifact (AI Agent type) achieved a score of 100%.

What the 42 tests validate

The test suite covers two complementary types of validation:

Unit tests verify the technical correctness of individual components:

• The three SAP API connectors (Business Partner, GL Account Line Items, Accounting Documents) return data in the expected format
• The reconciliation engine correctly compares balances across scenarios including partial payments and multiple open items
• The letter generation function produces structurally valid output for each supported letter template

AI-powered evaluations (evals) assess whether the agent’s outputs genuinely match the original intent:

• The LLM classification correctly identifies full confirmations, partial discrepancies, and disputes across a representative set of test requests
• Generated response letters are coherent, complete, and compliant with the required format and localization rules

What a 100% score means in practice

1. The reconciliation logic is correct across all test scenarios.
2. The LLM classification is reliable for all three request types.
3. The letter generation meets structural and compliance requirements.
4. Human-review routing is triggered precisely when - and only when - the PRD specifies it should be.

If any test fails, inspect the test log to identify which component produced the failure (ingestion, classification, reconciliation, letter generation, or routing). Review the relevant file in assets/ or refine the intent statement and regenerate from Phase 1 if the issue is structural.

With all 42 tests passed and a 100% validation score, the Automated Processing of Balance Confirmations agent is ready for deployment.

1. Select Deploy in the top right corner of the Testing screen.
2. Joule Studio packages the agent and deploys it to the SAP managed runtime service - the shared infrastructure that handles compute, scaling, connectivity, and runtime management for all Joule Studio solutions. You do not need to provision or operate any infrastructure manually.
3. Once deployment completes, the deploy_result.json file in the specification/ folder is populated with the live deployment details (endpoint URL, runtime ID, deployment timestamp).

Your agent is now operational.

How the agent works in production

Once live, the agent processes incoming balance confirmation requests automatically:

1. Ingestion - The agent detects an incoming request via email or document upload and ingests it.
2. Classification - The LLM classifies the request as a verification request, balance list request, or exception-only request.
3. Data retrieval - The agent calls the three MCP servers to fetch relevant open items, GL account line items, and accounting documents from live SAP S/4HANA data.
4. Reconciliation - The deterministic engine compares the business partner’s stated figures against the SAP data as of the stated reference date and flags any discrepancies.
5. Letter generation - The LLM drafts a localized, legally compliant response letter for the specific request type and reconciliation outcome.
6. Routing decision:
   • Fully matching: The response letter is dispatched automatically.
   • Discrepancy or dispute: The case is routed to a Finance team member for review and approval before the letter is sent.
7. Audit logging - Every#- request receipt, classification decision, reconciliation result, routing decision, and letter dispatch - is logged for full audit traceability.

The Finance team at RaiLona can query the audit log at any time to retrieve a complete, linked record of every balance confirmation request from ingestion to response - demonstrating audit-readiness to auditors and compliance teams.

You have completed the end-to-end creation and deployment of an Automated Processing of Balance Confirmations agent using SAP Joule Studio. In doing so, you have:

• Identified the three types of balance confirmation request (verification, balance list, exception-only) and the five manual pain points they create
• Written a focused intent statement that Joule Studio translated into a structured, production-ready solution
• Reviewed and validated an Idea Board, including the reflected intent, problem statement, five measurable goals, and a recommended architecture with a 92% intent fit score
• Evaluated a generated PRD, including product objectives, automation level, LLM vs. deterministic engine boundaries, read-only API access scope, and four operational guardrails
• Inspected a generated file tree structured with MCP servers - for SAP OData APIs - and understood the role of each component
• Interpreted a 42-test validation suite covering both unit tests and AI-powered evaluations, with a 100% pass rate
• Deployed the agent to the SAP managed runtime service and understood its end-to-end production behaviour - from ingestion to automatic dispatch or human-review routing

The agent turns what was previously a multi-step manual process - spanning multiple systems, tools, and document editors - into a guided, auditable, compliant workflow that Finance teams can rely on at every period-end and year-end close.