What are compensation events?

One of the outstanding features provided by Camunda 8 is its ability to easily handle business transactions that went awry. This workflow pattern allows businesses to define compensatory actions and “undo” steps in a workflow if some operations in the sequence fail. In today’s complex business processes spanning across distributed architectures, we can find many examples where executed tasks need to be undone to reflect the real-world state.

For example, when a system runs financial transactions, money transfers, or online credit applications, it needs to confirm the request, process the transaction, and update the account. If any of the stages are not completed, the system has to be capable of rolling the previous steps back to avoid incorrect transactions or data inconsistencies. Namely, it would be inappropriate to leave the credit request in the confirmed state if the loaned money didn’t arrive in the client’s account, say, because of a failure of a microservice.

So, in business operations, Camunda’s compensation events enable the automatic reversal of actions that were successfully completed, but their results and side effects are no longer seen as desirable. Thus, the compensation feature ensures the process is preserved in a consistent state in case of errors, exceptions, and cancellations.

How do compensation events work in Camunda 8?

Saga

To enforce effective compensation, Camunda supports Saga, an interaction pattern that works well in data consistency management across complex microservice architectures. Unlike the two-phase commit protocol frequently used in distributed systems, the Saga pattern doesn’t reduce the overall system availability with transaction locks. It is also perfectly suited to modern NoSQL databases and message brokers that don’t support two-phase commit.

Thus, Saga is the preferable option for long-running business processes and highly distributed systems, which are almost universal in banking nowadays. It breaks complex processes into small, manageable steps, each of them accompanied by a compensation action needed for correct recovery in case of failure. As a result, the system remains fault-tolerant and consistent while retaining scalability and performance.

Zeebe and BPMN

Camunda’s Zeebe engine works as a Saga Coordinator responsible for either completing the overall transaction or aborting it, bringing the system into a known termination state. The engine has a log-based, event-driven design, where every state change is captured in an append-only log. This allows for efficient recovery and state management, which is crucial for implementing compensation events.

Compensation events in Camunda are created using the BPMN 2.0 standard in Camunda Modeler. They work closely with the engine, which handles process execution efficiently and can scale well.

When a process instance enters a compensation intermediate throw or end event, it triggers the compensation within its scope and invokes all compensation handlers of completed activities. The compensation handlers of active or terminated activities are not invoked. The compensation throw event remains active until all invoked compensation handlers are completed.

Specifics for the implementation of Camunda’s compensation events

• Camunda makes it easy to model compensation in complex business processes with visual BPMN representations.
• Users can create a compensation activity for every task in a process model, be it a service task, a human task, or a subprocess.
• Camunda’s compensation can handle complicated situations like multiple instance activities, compensation handler interruption, triggering compensation handlers in a given order, and more.
• Users don’t need to hand-code rollback logic across multiple microservices and can build robust error-handling mechanisms directly into their process models.

All in all, compensation flows built in Camunda save you the trouble of tracking each transaction individually and ease the complexity of rollbacks.

Real case of a compensation event for banking

Let’s look at how Camunda’s compensation works in a real-life banking scenario of transferring funds. As we’d like to focus on compensation events, we will slightly simplify the process by combining all client validations taking place before a fund transfer into one service task. The validation activities include:

• Checking the format and correctness of the data entered, such as IBANs and bank details
• Confirming that the specified amount does not exceed existing limits
• Verifying the sufficiency of funds in the sender’s account
• Identity verification
• Anti-fraud, anti-money laundering, and compliance checks

The diagram below shows the following scenarios:

1. If any problems are detected during the data validation, Camunda sends a notification informing the client about the fund transfer cancellation. The process is completed.
2. If the validation is successful, the process goes on.
3. In the next step, the sending bank writes off the specified amount from the client’s account. All the operations with the account are logged in the system.
4. If something goes wrong during the write-off (the connection was broken, the bank did not send a response about debiting the account, etc.), Camunda informs the client that the fund transfer process ends in an error. The process is completed.
5. If the write-off operation is successful, the process continues.
6. The next step is replenishing the receiver’s account with the specified amount.
7. If the system identifies an error boundary event during the execution of this operation, Camunda informs the client and triggers a compensation event—a rollback of writing off the funds from the client’s account. Then, the process is completed.
8. If the crediting causes no errors, Camunda logs the account replenishment operation and notifies the recipient of the funds added to their balance. The process is completed.

By implementing the compensation event, the bank ensures no funds are lost or incorrectly processed, maintaining data consistency and complying with regulatory requirements.

Compensation events: use cases and benefits for banking

Compensation events aren’t limited to simple debit-credit operations. They can be used across a wide range of banking processes:

• Loan application processing. An approved loan can be rolled back automatically when a post-approval check fails.
• Fraud detection. It is possible to reverse a flagged fraudulent transaction and notify the relevant departments in the process.
• Cross-border payments. In case of exchange rate mismatches or compliance violations, multiple currency conversions and international transfer operations can be efficiently handled with compensatory actions.
• Lending and mortgage transactions. If the credited party changes their mind or calculation errors are detected, it will be appropriate to change the agreement terms or roll the whole process back with compensation events.
• Commission and fee calculation. When a customer is mistakenly charged a commission or fee, a refund is a surefire way of correcting the situation.
• Settlements and clearing operations. In the event of failures in clearing processes (for example, in interbank transfers), compensation events can roll back and re-execute transactions or ensure the funds’ reversal.
• Payment systems and acquiring. When a payment system fails to process a payment, it can use compensation events to cancel the transaction and return the funds to the customer.
• Card transactions. Returning funds or cancelling the transaction will also be helpful in case of an erroneous debiting, for example, because of duplicate transactions.
• Currency transactions. If there is a change in the exchange rate during the conversion process, compensation events may adjust the original transaction or return funds with due regard to the new conditions.
• Deposit transactions. If a client terminates a deposit agreement early or there are errors in interest calculations, compensation events may adjust the maths or roll back the transactions.

By adopting automated compensation and letting Camunda coordinate complex banking processes, financial institutions can reap many benefits:

1. Minimise financial risk. By defining compensation flows, banks can reduce the risk of incomplete or erroneous transactions, ensuring that funds are accurately handled.
2. Ensure compliance. Automated rollbacks help prevent unauthorised or incomplete transactions and thus work toward meeting regulatory requirements like the PCI DSS and GDPR.
3. Reduce manual workload. Compensation events allow banks to eliminate manual intervention in case of transaction failures, freeing up valuable human resources for more high-value tasks.
4. Enhance customer trust. Banks can build greater customer trust by implementing accurate and transparent transaction processing.

Using compensation events beyond banking 
As event-based, distributed architectures are frequently found outside the financial industry, Camunda’s compensation solution has a much broader application area. Here are some examples of the compensation events usage in other industries:

• Supply chain management: Prevent stock discrepancies by reversing inventory changes if a shipment fails.
• Healthcare: Handle errors in patient data processing or treatment scheduling when managing clinical trials.
• E-commerce: Automatically cancel order confirmations and refund payments in case of errors in order processing or payment authorisation.
• Insurance: Ensure accurate financial records by cancelling overpayments or rectifying policy processing errors.

Final thoughts

By leveraging compensation events, organisations can build more resilient and adaptable process automation frameworks. Thanks to the faster recovery from failures and the reduced risk of process downtime ensured by automated compensation, businesses become more agile and competitive. Camunda 8 provides a powerful mechanism for banks to handle the complexity of modern financial transactions with confidence. By automating rollback actions, they can meet regulatory requirements and enhance operational efficiency while offering a more secure and reliable banking experience for their customers. Contact Camunda or a certified Camunda partner to get professional help in designing your compensation events.

Editor’s Note: This post was written by Maria Alish, a Camunda Champion. Would you like to become a Camunda Champion, and potentially have your blog post published here as well? Learn more about our Champion Program and how you can apply.

The post How a Bank Uses Compensation Events in Camunda 8 appeared first on Camunda.

It’s one thing to get a large language model (LLM) to generate a summary, write an email, or classify a support ticket. It’s another entirely to make sure that use of AI fits your company’s legal, ethical, operational, and technical policies. That’s where governance comes in—and frankly, it’s where most organizations are struggling to find their footing.

The challenge isn’t just technical. Sure, you need to worry about prompt injection attacks, hallucinations, and model drift. But you also need to think about compliance audits, cost control, human oversight, and the dreaded question from your CEO: “Can you explain why the AI made that decision?” These aren’t abstract concerns anymore—they’re real business risks that can derail AI initiatives faster than you can say “responsible deployment.”

That’s where Camunda comes into the picture. We’re not an AI governance platform in the abstract sense. We don’t decide your policies for you, and we’re not going to tell you whether your use case is ethical or compliant. But what we do provide is something absolutely essential: a controlled environment to integrate, orchestrate, and monitor AI usage inside your processes, complete with the guardrails and visibility that support enterprise-grade governance.

Think of it this way: if AI governance is about making sure your organization uses AI responsibly, then Camunda is the operational backbone that makes those policies actually enforceable in production systems. We’re the difference between having a beautiful AI ethics document sitting in a SharePoint folder somewhere and actually implementing those principles in your day-to-day business operations.

This post will explore how Camunda fits into the broader picture of AI governance, diving into specific features—from agent orchestration to prompt tracking—that help you operationalize your policies and build trustworthy, compliant automations.

What is AI governance, and where does Camunda fit?

Before we dive into the technical details, it’s worth stepping back and talking about what AI governance actually means. The term gets thrown around a lot, but in practice, it covers everything from high-level ethical principles to nitty-gritty technical controls.

We’re framing this discussion around the “AI Governance Framework” provided by ai-governance.eu, which defines a comprehensive model for responsible AI oversight in enterprise and public-sector settings. The framework covers organizational structures, procedural requirements, legal compliance, and technical implementations.

Camunda plays a vital role in many areas of governance, but none more so than the “Technical Controls (TeC)” category.. This is where the rubber meets the road—where your governance policies get translated into actual system behaviors. Technical controls include enforcing process-level constraints on AI use, ensuring explainability and traceability of AI decisions, supporting human oversight and fallback mechanisms, and monitoring inputs, outputs, and usage metrics across your entire AI ecosystem.

Here’s the crucial point: these technical controls don’t replace governance policies—they ensure that those policies are actually followed in production systems, rather than just existing as aspirational documents that nobody reads.

1. Fine-grained control over how AI is used

The first step to responsible AI isn’t choosing the right model or writing the perfect prompt—it’s being deliberate about when, where, and how AI is used in the first place. This sounds obvious, but many organizations end up with AI sprawl, where different teams spin up AI integrations without any coordinated approach to governance.

With Camunda, AI usage is modeled explicitly in BPMN (Business Process Model and Notation), which means every AI interaction is part of a documented, versioned, and auditable process flow.

You can design processes that use Service Tasks to call out to LLMs or other AI services, but only under specific conditions and with explicit input validation. User Tasks can involve human reviewers before or after an AI step, ensuring critical decisions always have human oversight. Decision Tables (DMN) can evaluate whether AI is actually needed based on specific inputs or context. Error events and boundary events capture and handle failed or ambiguous AI responses, building governance directly into your process logic.

Because the tasks executed by Camunda’s AI agents are defined with BPMN, those tasks can be deterministic workflows themselves, ensuring that, on a granular level, execution is still predictable.

This level of orchestration lets you inject AI into your business processes on your own terms, rather than letting the AI system dictate behavior. You’re not just calling an API and hoping for the best—you’re designing a controlled environment where AI operates within explicit boundaries.

Here’s a concrete example: if you’re processing insurance claims and want to use AI to classify them as high, medium, or low priority, you can insert a user task to verify all “high priority” classifications before they get routed to your fraud investigation team. You can also add decision logic that automatically escalates claims above a certain dollar amount, regardless of what the AI thinks. This way, you keep humans in the loop for critical decisions without slowing down routine processing.

2. Your models, your infrastructure, your rules

One of the most frequent concerns about enterprise AI adoption centers on data privacy and vendor risk. Many organizations have strict requirements that no customer data, internal business logic, or proprietary context can be sent to third-party APIs or cloud-hosted LLMs.

Camunda’s approach to agentic orchestration supports complete model flexibility without sacrificing governance capabilities. You can use OpenAI, Anthropic, Mistral, Hugging Face, or any provider you choose, and, starting with Camunda 8.8 (coming in October 2025), you can also route calls to self-hosted LLMs running on your own infrastructure. Whether you’re running LLaMA 3 on-premises, using Ollama for local development, or connecting to a private cloud deployment, Camunda treats all of these as different endpoints in your process orchestration.

There’s no “magic” behind our AI integration—we provide open, composable connectors and SDKs that integrate with standard AI frameworks like LangChain. You control the routing logic, prompt templates, authentication mechanisms, and access credentials. Most importantly, your data stays exactly where you want it.

For example, a financial services provider might route customer account inquiries to a cloud-hosted model, but keep transaction details and personal financial information on-premises. With Camunda, you can model this routing logic explicitly using decision tables to determine which endpoint to use based on content and context.

3. Design AI tasks with guardrails: Preventing prompt injection and hallucinations

Prompt injection isn’t just a theoretical attack—it’s a real risk that can have serious business consequences. Any time an AI model processes user-generated input, there’s potential for malicious content to manipulate the model’s behavior in unintended ways.

Camunda helps mitigate these risks by providing structured approaches to AI integration. All data can be validated and sanitized before it is used in a prompt, preventing raw input from reaching the models. Prompts are designed using FEEL (Friendly Enough Expression Language), allowing prompts to be flexible and dynamic. This centralized prompt design means prompts become part of your process documentation rather than buried in application code. Camunda’s powerful execution listeners can be utilized to analyze and sanitize the prompt before it is sent to the agent.

Decision tables provide another layer of protection by filtering or flagging suspicious content before it reaches the model. You can build rules that automatically escalate requests containing certain keywords or patterns to human review.

When you build AI tasks with Camunda’s orchestration engine, you create a clear separation between the “business logic” of your process and the “creative output” of the model. This separation makes it much easier to test different scenarios, trace unexpected behaviors, and implement corrective measures. Camunda’s AI Task Agent supports guardrails, such as limiting the number of iterations it can perform, or the maximum number of tokens per request to help control costs.

4. Monitoring and auditing AI activity

You can’t govern what you can’t see. This might sound obvious, but many organizations deploy AI systems with minimal visibility into how they’re actually being used in production.

Optimize gives you comprehensive visibility into AI usage across all your processes. You can track the number of AI calls made per process or task, token usage (and therefore associated costs), response times and failure rates, and confidence scores or output quality metrics when available from your models.

This monitoring data supports multiple governance objectives. For cost control, you can spot overuse patterns and identify inefficient prompt chains. For policy compliance, you can prove that AI steps were reviewed when required. For performance tuning, you can compare model outputs over time or across different vendors to optimize both cost and quality.

You can build custom dashboards that break down AI usage by business unit, region, or product line, making AI usage measurable, accountable, and auditable. When auditors ask about your AI governance, you can show them actual data rather than just policy documents.

5. Multi-agent systems, modeled with guardrails

The future of enterprise AI isn’t just about better individual models—it’s about creating systems where multiple AI agents work together to achieve complex business goals.

Camunda’s agentic orchestration lets you design and govern these complex systems with the same rigor you’d apply to any other business process. Each agent—whether AI, human expert, or traditional software—gets modeled as a task within a larger orchestration flow. The platform defines how agents collaborate, hand off work, escalate problems, and recover from failures.

You can design parallel agent workflows with explicit coordination logic, conditional execution paths based on agent outputs, and human involvement at any point where governance requires it. Composable confidence checks ensure work only proceeds when all agents meet minimum quality thresholds.

Here’s a concrete example: in a legal document review process, one AI agent extracts key clauses, another summarizes the document, and a human attorney provides final review. Camunda coordinates these steps, tracks outcomes, and escalates if confidence scores are low or agents disagree on their assessments.

6. Enabling explainability and traceability

One of the most challenging aspects of AI governance is explainability. When an AI system makes a decision that affects your business or customers, stakeholders want to understand how and why that decision was made—and this is often a legal requirement in regulated industries.

Modern AI models are probabilistic systems that don’t provide neat explanations for their outputs. But Camunda addresses this by creating comprehensive audit trails that capture the context and process around every AI interaction.

For every AI step, Camunda persists the inputs provided to the model, outputs generated, and all prompt metadata. Each interaction gets correlated with the exact process instance that triggered it, creating a clear chain of causation. Version control for models, prompts, and orchestration logic means you can trace any historical decision back to the exact system configuration that was in place when it was made.

Through REST APIs, event streams, and Optimize reports, you can answer complex questions about AI usage patterns and decision outcomes. When regulators ask about specific decisions, you can provide comprehensive answers about what data was used, what models were involved, what confidence levels were reported, and whether human review occurred.

Camunda as a cornerstone of process-level AI governance

AI governance is a team sport that requires coordination across multiple organizational functions. You need clear policies, compliance frameworks, technical implementation, and ongoing oversight. No single platform can address all requirements, nor should it try to.

What Camunda brings to this collaborative effort is operational enforcement of governance policies at the process level. We’re not here to define your ethics policies—we provide the technical infrastructure to ensure that whatever policies you establish actually get implemented and enforced in your production AI systems.

Camunda gives you fine-grained control over exactly how AI gets used in your business processes, complete flexibility in model and hosting choices, robust orchestration of human-in-the-loop processes, comprehensive monitoring and auditing capabilities, protection against AI-specific risks like prompt injection, and support for cost tracking and usage visibility.

You bring the policies, compliance frameworks, and business requirements—Camunda helps you enforce them at runtime, at scale, and with the visibility and control that enterprise governance demands.

If you’re looking for a way to govern AI at the process layer—to bridge the gap between governance policy and operational reality—Camunda offers the controls, insights, and flexibility you need to do it safely, confidently, and sustainably as your AI initiatives grow and evolve.

Learn more

Looking to get started today? Download our ultimate guide to AI-powered process orchestration and automation to discover how to start effectively implementing AI into your business processes quickly.

The post Ensuring Responsible AI at Scale: Camunda’s Role in Governance and Control appeared first on Camunda.

That’s what NatWest Bank, a leading retail and commercial bank in the UK, set out to do with the help of Camunda. Joanne Barry, Head of Technology Fraud Prevention COE at NatWest, led off her recent CamundaCon presentation by quoting the CEO of NatWest, Paul Thwaite, whose stated goal is to “build a simpler, more integrated and technology-driven bank that is capable of even greater impact.” One of the most powerful ways to do that in 2025 is by operationalizing AI.

A complex environment

Milesh Chudasama, Digital Transformation Director at NatWest, then took the stage to set the scene. The Fraud Center of Excellence group at NatWest includes over 800 fraud center agents using an average of 14 applications per call, with over 60 tools available to them across a range of platforms.

As you can imagine, this is a complex setup and it takes a long time to train people well to provide a good customer experience and to be in full compliance with regulations. And when they leave, all that painstaking training goes with them.

The lack of standardization

Inconsistency from a lack of standardization is a big problem. This not only means that customers are not served in the same way every call, but it also means that processes are often recreated across multiple platforms, duplicating effort.

Milesh explained that a lack of orchestration is holding them back, and that “what we want to do is create a good solid process orchestration engine.” This will enable a headless architecture that they can replicate across as many platforms as they need to, saving enormous amounts of time and effort.

Unlocking the value of AI for fraud detection

NatWest is looking for AI to drive specific business outcomes. Joanne explained, “We know AI will transform our ability to deliver” these key results:

1. Increase customer engagement
2. Maximize agility
3. Drive operating leverage

To drive those outcomes, they have outlined a series of initiatives where AI can produce valuable results. As Milesh put it, the goal is to “use AI in the right way, and not let it run free… and do some stuff that can damage your reputation.”

Analyzing and digesting large amounts of data, along with writing and testing code, were powerful ways that the team is able to use AI to speed up their work and reduce their time to market. AI can also build on existing rules-based systems for something like anomaly detection, helping them detect patterns quickly and be more proactive, rather than reactive.

One exciting initiative included using AI within Camunda to move “the creation of initial BPMN diagrams to the left, so that the business generates it themselves,” which will result in much tighter business-IT alignment and accelerate the way they build processes to begin with. AI will also help the team reduce the number of applications they need to touch to solve a problem, improving the way a process is “governed and managed by a human and an AI agent” or by straight-through processing.

Disrupt and transform

AI clearly has the power to both disrupt and transform banking and financial services. The team at NatWest has identified a number of opportunities.

• Customer experience: AI can respond faster and automate more cases, improving customer satisfaction.
• Engineering productivity: AI tools can help teams write code or design BPMN diagrams much more rapidly than before, speeding up production and making collaboration easier.
• Process simplification: Features like Optimize give them data points so they can understand what works and what doesn’t, and where AI can be most effective.
• Fraud/Financial crime: Understanding patterns and which things to react to and which not to, which is critical with the reports of fraud growing daily.

One key Milesh highlighted was the ability to determine “how far you want the AI to service a customer before you break out from the AI” and hand off to a human. This is a critical step in ensuring a good customer experience and avoiding the problems of AI attempting to navigate an issue that is too complex for it.

What’s next?

Milesh noted that what he really wants his team to do is make sure the customer gets the same journey no matter how they interact with the company. “Not omnichannel,” he observed, “let’s call it optichannel—the right customer to the right journey to get the right output.” Using tools like Optimize to simplify and automate processes, and orchestrating end-to-end with Camunda to better understand processes and remove human touchpoints where it’s most effective, will help them get there faster.

See the full presentation and more from CamundaCon Amsterdam 2025

You can check out the full presentation from NatWest here or watch it below, and for more be sure to check out all the recordings from CamundaCon Amsterdam 2025.

If you liked this and wish you’d seen it live, don’t miss your chance to join us at the next CamundaCon! Register now for CamundaCon New York 2025.

The post Reinventing Fraud Detection: NatWest’s Journey to Operationalize AI with Camunda appeared first on Camunda.

In this post, we’ll walk through what RPA is, how to tackle the RPA Challenge using Camunda’s tools, from scripting the bot to deploying and executing it within a BPMN workflow, and finally how process orchestration can help super-charge your RPA bots.

What is RPA, and why should you care?

Robotic Process Automation (RPA) is a technology that allows you to automate repetitive, rule-based tasks typically performed by humans. Think of actions like copying data between systems, filling out web forms, or processing invoices—if it follows a predictable pattern, RPA can probably handle it. The goal is to free up people from mundane work so they can focus on higher-value tasks that require creativity, problem-solving, or empathy.

At the heart of RPA is the RPA bot, a small script that mimics human actions on a computer. These bots can click buttons, read emails, move files, enter data, and more. They’re like digital assistants that never sleep, don’t make typos, and follow instructions exactly as given. And unlike traditional software scripts, RPA bots are often designed to work with existing user interfaces, so you don’t need to rebuild backend systems to automate work.

If you already use process orchestration, why use RPA at all? Because it’s a fast, cost-effective way to automate existing business processes without major changes to your IT infrastructure. Whether you’re streamlining internal workflows or integrating legacy systems with modern platforms like Camunda, RPA gives you the power to get more done, faster—and with fewer errors. When combined with process orchestration, it becomes even more powerful, allowing bots to operate as part of larger, end-to-end business processes.

Follow along with the video

We’re going to dig into the RPA Challenge with a full tutorial below, but feel free to follow along with the video as well.

Understanding the RPA script

To solve the RPA Challenge, we used a script written in Robot Framework, a generic open-source automation framework. The script is built with Camunda’s RPA components, allowing seamless orchestration within a BPMN process. You can view the full script, as well as a BPMN model that uses the script, by clicking here. In this section, we’ll walk through the script in detail.

Settings

*** Settings ***
Documentation       Robot to solve the first challenge at rpachallenge.com,
...                 which consists of filling a form that randomly rearranges
...                 itself for ten times, with data taken from a provided
...                 Microsoft Excel file. Return Congratulation message to Camunda.
Library             Camunda.Browser.Selenium    auto_close=${False}
Library             Camunda.Excel.Files 
Library             Camunda.HTTP
Library             Camunda

The Settings section defines metadata and dependencies for the script:

• Documentation: A human-readable description of what the robot does. In this case, it describes the task of filling a dynamically rearranging form using Excel data.
• Library: These lines load external libraries required for the script to run. Robot Framework supports many built-in and third-party libraries. When using Camunda’s implementation, you can also use Camunda-specific RPA libraries tailored to browser automation, Excel file handling, HTTP actions, and integration with the Camunda platform.

When writing a RPA script, you can import as many libraries as needed to accomplish the task at hand. Here’s what each library used in this challenge does:

• Camunda.Browser.Selenium: Enables browser automation via Selenium. The auto_close=${False} argument ensures the browser doesn’t automatically close after execution, useful for debugging.
• Camunda.Excel.Files: Provides utilities to read data from Excel files, which is essential for this challenge.
• Camunda.HTTP: Used to download the Excel file from the RPA Challenge site.
• Camunda: Core Camunda RPA library that helps interact with the platform, such as setting output variables for process orchestration.

Tasks

*** Tasks ***
Complete the challenge
    Start the challenge
    Fill the forms
    Collect the results

The Tasks section defines high-level actions that the robot will execute. In Robot Framework, a “task” is essentially a named sequence of keyword calls and defines every action the robot will take.

Each task is given a friendly name (for this challenge, the task is named “Complete the challenge”). This task is composed of three keyword invocations:

• Start the challenge: Opens the site and prepares the environment.
• Fill the forms: Loops through the Excel data and fills out the form.
• Collect the results: Captures the output message after the form submissions are complete.

Each of these steps corresponds to a custom keyword defined in the next section.

Keywords

The Keywords section is where we define reusable building blocks of the automation script. Keywords are like functions or procedures. Each keyword performs a specific operation, and you can call them from tasks or other keywords. The order keywords are defined does not matter, as they are executed individually as defined in the task.

Let’s break down each one.

Start the challenge

Start the challenge
    Open Browser   http://rpachallenge.com/         browser=chrome
    Maximize Browser Window
    Camunda.HTTP.Download
    ...    http://rpachallenge.com/assets/downloadFiles/challenge.xlsx
    ...    overwrite=True
    Click Button    xpath=//button[contains(text(), 'Start')]

This keyword sets up the browser environment and downloads the data file required for the challenge. It begins by launching a Chrome browser using the Open Browser keyword, which is part of the Camunda.Browser.Selenium library imported earlier, and navigates to rpachallenge.com. Once the site loads, the Maximize Browser Window keyword ensures that all elements on the page are fully visible and accessible for automation.

The script then uses the Camunda.HTTP.Download keyword from the Camunda.HTTP library to download the Excel file containing the challenge data; the overwrite=True argument ensures that an up-to-date version of the file is used each time the bot runs. Finally, it clicks the “Start” button on the page using the Click Button keyword, targeting the element via an XPath expression that identifies the button by its text. This action triggers the start of the challenge and reveals the form to be filled.

This keyword sets the stage for the main task by ensuring we’re on the correct page and have the necessary data.

Fill the forms

Fill the forms
    ${people}=    Get the list of people from the Excel file
    FOR    ${person}    IN    @{people}
        Fill and submit the form    ${person}
    END

This keyword performs the core automation logic by iterating over the data and filling out the form multiple times. It starts by calling the custom keyword Get the list of people from the Excel file, which reads the downloaded Excel file and returns its contents as a table—each row representing a different person.

The script then enters a loop using Robot Framework’s FOR ... IN ... END syntax, iterating through each person in the dataset. Within this loop, it calls the Fill and submit the form keyword, passing in the current person’s data. This step ensures that the form is filled and submitted once for every individual listed in the Excel file, effectively completing all ten iterations of the challenge.

The keyword demonstrates how modular and readable Robot Framework scripts can be. Each action is broken into self-contained logic blocks, which keeps the code clean and reusable.

Get the list of people from the Excel file

Get the list of people from the Excel file
    Open Workbook    challenge.xlsx
    ${table}=    Read Worksheet As Table    header=True
    Close Workbook
    RETURN    ${table}

This keyword is responsible for reading and parsing the data from the Excel file. It begins by using the Open Workbook keyword to open the downloaded challenge.xlsx file. Once the file is open, the Read Worksheet As Table keyword reads the contents of the worksheet and stores it as a table, with the header=True argument ensuring that the first row is treated as column headers—making the data easier to work with.

After reading the data, the Close Workbook keyword is called to properly close the file, which is a best practice to avoid file access issues. Finally, the keyword returns the parsed table using RETURN ${table}, allowing the calling keyword to loop through each row in the dataset.

The result is a list of dictionaries, where each dictionary represents a person’s data (e.g., first name, last name, email, etc.).

Fill and submit the form

Fill and submit the form
    [Arguments]    ${person}
    Input Text    xpath=//input[@ng-reflect-name="labelFirstName"]    ${person}[First Name]
    Input Text    xpath=//input[@ng-reflect-name="labelLastName"]    ${person}[Last Name]
    Input Text    xpath=//input[@ng-reflect-name="labelCompanyName"]    ${person}[Company Name]
    Input Text    xpath=//input[@ng-reflect-name="labelRole"]    ${person}[Role in Company]
    Input Text    xpath=//input[@ng-reflect-name="labelAddress"]    ${person}[Address]
    Input Text    xpath=//input[@ng-reflect-name="labelEmail"]    ${person}[Email]
    Input Text    xpath=//input[@ng-reflect-name="labelPhone"]    ${person}[Phone Number]
    Click Button    xpath=//input[@type='submit']

This keyword fills out the web form using data for a single person. It begins with the [Arguments] ${person} declaration, which accepts a dictionary containing one individual’s details—such as name, email, and company information—retrieved from the Excel file. The form fields are then populated using multiple Input Text keywords, each one targeting a specific input element on the page. These fields are identified using XPath expressions that match the ng-reflect-name attributes, ensuring the correct data is entered in the right place regardless of how the form rearranges itself. Once all fields are filled in, the Click Button keyword is used to submit the form, completing one iteration of the challenge.

The challenge dynamically rearranges form fields on each iteration, but these attributes remain consistent, making them a reliable way to target inputs.

Collect the results

Collect the results
    ${resultText}=    Get Text    xpath=//div[contains(@class, 'congratulations')]//div[contains(@class, 'message2')]
    Set Output Variable    resultText    ${resultText}
    Close Browser

After all the forms have been submitted, this keyword captures the final confirmation message displayed by the RPA Challenge. It starts by using the Get Text keyword to extract the congratulatory message shown on the screen, targeting the message element with an XPath expression that identifies the relevant section of the page.

The retrieved message is then passed to Camunda using the Set Output Variable keyword, which makes the result available to the surrounding BPMN process—allowing downstream tasks or process participants to use or display the outcome. Finally, the Close Browser keyword is called to shut down the browser window and clean up the automation environment.

Testing, deploying and executing with Camunda

Once your RPA script is ready, the next step is to test and integrate it into a Camunda workflow so it can be executed as part of a larger business process. To begin, you’ll need to download and install Camunda Modeler, a desktop application used to create BPMN diagrams and manage automation assets like RPA scripts. (Note: RPA scripts cannot be edited in Web Modeler currently; this feature is in development.) Desktop Modeler includes an RPA Script Editor, which allows you to open, write, test, and deploy Robot Framework scripts directly from within the application.

Before deploying the script to Camunda, it’s a good idea to test it locally. Start by launching a local RPA worker—a component that polls for and executes RPA jobs. You can find setup instructions for the worker in Camunda’s Getting Started with RPA guide. Once your worker is running, use the RPA Script Editor in Camunda Modeler to open your script and run it. This will launch the browser, execute your automation logic, and allow you to verify that the bot behaves as expected and completes the RPA Challenge successfully.

After confirming the script works, you can deploy it to your Camunda 8 cluster. Ensure that you have set an “ID” for the RPA script; this ID is how your BPMN process will reference and invoke the script. In the Modeler, click the “Deploy” button in the RPA Script Editor and choose the target cluster.

Next, create a new BPMN model in the Camunda Modeler to orchestrate the RPA bot. Start with a simple diagram that includes a Start Event, a Task, and an End Event. Select the Task and change it to the “RPA Connector”. Then, in the input parameters for the task, set the “Script ID” parameter to the ID you set in the RPA script earlier.

Once your BPMN model is ready, deploy it to the same Camunda cluster. To execute the process, you can either use the Camunda Console’s UI to start a new process instance or call the REST API. The RPA Worker will pick up the job, run the associated script, and return any output variables—like the final confirmation message from the RPA Challenge—back to Camunda. You can monitor the execution and troubleshoot any issues in Camunda Operate, which provides visibility into your running and completed processes, including logs and variable values.

With that, your RPA script is fully integrated into a Camunda process. You now have a bot that not only completes the challenge but does so as part of a well-orchestrated, transparent, and scalable business workflow.

How Camunda supercharges your RPA bots

RPA is great at automating individual tasks—but what happens when you need to coordinate multiple bots, connect them with human workflows, or make them part of a larger business process? That’s where Camunda comes in.

Camunda is a process orchestration platform that helps you model, automate, and monitor complex business processes from end to end. Think of it as the brain that tells your RPA bots when to run, what data to use, and how they fit into the bigger picture. With Camunda, your bots are no longer isolated automation islands—they become integrated, managed components of scalable workflows.

For example, you might use a Camunda BPMN diagram to define a process where:

1. A customer submits a request (via a form or API),
2. An RPA bot retrieves data from a legacy system,
3. A human reviews the output,
4. Another bot sends the results via email.

Camunda handles all of this orchestration—making sure each task runs in the right order, managing exceptions, tracking progress, and providing visibility through tools like Camunda Operate. And because Camunda is standards-based (using BPMN), you get a clear, visual representation of your processes that both developers and business stakeholders can understand.

When you combine RPA with Camunda, you’re not just automating tasks—you’re transforming how your organization runs processes. You get flexibility, scalability, and transparency, all while reducing manual effort and human error. Whether you’re scaling up existing bots or orchestrating new workflows from scratch, Camunda makes your RPA investments go further.

Conclusion

Automating the RPA Challenge with Camunda showcases our ability to handle dynamic, UI-based tasks seamlessly. By combining Robot Framework scripting with Camunda’s orchestration capabilities, you can build robust automation workflows that integrate both modern and legacy systems.

Ready to take your automation to the next level? Explore Camunda’s RPA features and see how they can streamline your business processes. Be sure to check out our blog post on how to Build Your First Camunda RPA Task as well.

The post Solving the RPA Challenge with Camunda appeared first on Camunda.

Most agent builders will wrap up those three requirements into a single, static, synchronous system, but at Camunda we decided not to do this. We found that it creates too many use case limitations, it’s not scalable and it’s hard to maintain. To overcome these limitations, we came up with a concept that lets us decouple these requirements and completely visualize an agent in a way that opens it up to far more use cases, not only on a technical level, but also in a way that  alleviates a lot of the fears that people have when adding AI agents as part of their core processes.

The value of a complete visualization

Getting insight into how an AI Agent has performed in a given task often requires someone to read through its chain of thought (this is like the AI’s private journal, where it details how it’s thinking about the problem). This will usually let you know what tools it decided to use and why. So in theory if you wanted to check on how your AI Agent was performing, you could read through it. In practice, this is just not practical for two reasons:
1. It limits the visibility of what happened to a text file that needs to be interpreted.
2. AI agents can sometimes lie in their chain of thought—so it might not even be accurate.

Our solution to this is to completely visualize the agent, its tools and its execution all in one place.

Gain full visibility into AI agent performance with BPMN

The diagram above shows a BPMN process that has implemented an AI agent. It’s in two distinct parts. The agent logic is contained within the AI Task Agent activity and the tools it has access to is displayed with an ad-hoc sub-process. This is a BPMN construct that allows for completely dynamic execution of the tasks within it.

With this approach the action of an agent is completely visible to the user in design time, during execution, and can even be used to evaluate how well the process performs with the addition of an agent.

The diagram above shows a headmap which shows which tools take the longest to run. This is something impossible to accurately measure with a more traditional AI agent building approach.

Decoupling tools from agent logic

This design completely decouples the agent logic from the available tool set. Meaning that the agent will find out only in runtime what tools are at its disposal. The ramifications of this are actually quite profound. It means that you can run multiple versions of the same process with the same agent, but a completely different tool set. This makes context reversing far easier and also lets us qualitatively evaluate the impact of adding or removing certain tools through AB testing.

Improving maintainability for your AI agents

The biggest impact of this decoupling in my opinion though is how it improves maintainability. Designers of the process can add or remove new tools without ever needing to change or update the AI agent. This is a fantastic way of separating responsibilities when a new process is being built. While AI experts can focus on ensuring the AI Task Agent is properly configured, developers can build the tooling independently. And of course, you can also just add pre-built tools for the agent to use.

Composable design

Choosing, as we did, to marry AI agent design with BPMN design means we’ve unlocked access for AI agent designers to all the BPMN patterns, best practices and functionality that Camunda has been building over the last 10 years or so. While there’s a lot you gain because of that, I want to focus on just one here: Composable architecture.

Composable orchestration is the key to operationalizing AI

Camunda is designed to be an end-to-end orchestrator to a diverse set of tools, rules, services and people. This means we have designed our engine and the tools around it so that there is no limitation on what can be integrated. It also means we want users to be able to switch out services and systems over time, as they become legacy or a better alternative is found.

This should be of particular interest to a developer of AI agents because it lets you not only switch out the tools the AI Agent has access to, but more importantly, it lets you switch out the agent’s own LLM for the latest and greatest. So to add or even just test out the behaviour of a new LLM no longer means building a new agent from scratch—just swap out the brain and keep the rest. This alone is going to lead to incredibly fast improvements and deployments to your agents, and help you make sure that a change is a meaningful and measurable one.

Conclusion

Building AI agents the default way that other tools offer right now leads you to adding a new black box to your system. One that is less maintainable and and far more opaque in execution than anything else you’ve ever integrated. This is going to make it hard to properly maintain and evaluate.

At Camunda we have managed to open up that black box in a way that integrates it directly into your processes as a first-class citizen. Your agent will immediately benefit from everything that BPMN does and become something that can grow with your process.

It’s important to understand that you’re still adding a completely dynamic aspect to your process, but this way you mitigate most concerns early on. For all these reasons, I can imagine that of all the many, many AI agents that are going to be built this year, I’m sure the only ones that will still be used by the end of next year will be built in Camunda with BPMN.

Try it out

All of this is available for you to try out in Camunda today. Learn more about how Camunda approaches agentic orchestration and get started now with a free trial here.

The post The Benefits of BPMN AI Agents appeared first on Camunda.

How to build an AI Agent in BPMN with Camunda

There are two aspects to building an AI Agent in BPMN with Camunda.

1. Defining the AI Task Agent
2. Defining the available tools for the agent.

The AI Task Agent is the brain, able to understand the context and the goal and then to use the tools at its disposal to complete the goal. But where are these tools?

Adding new tools to your AI agent

The tools for your AI agent are defined inside an ad-hoc sub-process which the agent is told about. So assuming you’ve set up your Task Agent already—and you can! Because you just need the process model from this github repo. The BPMN model without any tools should look like this:

Basically I’ve removed all the elements from within the ad-hoc sub-process. The agent still has a goal—but now has no way of accomplishing that goal.

In this guide we’re going to add a task to the empty sub-process. By doing this, we’ll give the AI Task Agent access to it as a tool it can use if it needs to.

The sub-process has a multi-instance marker, so for each tool to be used there’s a local variable called toolCall that we can use to get and set variables.

I want to let the AI agent ask a human a technical question, so first I’m going to add a User Task to the sub-process.

Defining the tool for the agent

The next thing we need to do is somehow tell the agent what this tool is for. This is done by entering a natural language description of the tool in the Element Documentation field of the task.

Defining variables

Most tools are going to request specific variables in order to operate. Input variables are defined so that the agent is aware of what’s required to run the tool in question. It also helps pass the given context of the current process to the tool. Output variables define how we map the response from the tool back into the process instance, which means that the Task Agent will be aware of the result of the tool’s execution.

In this case, to properly use this tool, the agent will need to come up with a question.

For a User Task like this we will need to create an input variable like the one you see below.

In this case we created a local variable, techQuestion, directly in the task. We’ll then both assign this variable and define it for the task agent we need to call the fromAi function. To do that we must provide:

1. The location of the variable in question.
   • In this case that would be within the toolCall variable.
2. A natural language description of what the variable is used for.
   • Here we describe it as the question that needs to be asked.
3. The variable type.
   • This is a string, but it could be any other primitive variable type.

When all put together, it looks like this:

fromAi(toolCall.techQuestion, "This is a specific question that you’d like to ask", "string")

Next we need an output variable so that the AI agent can be given the context it needs to understand if running this tool produced the output it expected. In this case, we want it to read the answer from the human expert it’s going to consult.

This time, create an output variable. You’ll have two fields to fill in.

1. Process variable name
   • It’s important that this variable name matches the output expected by the sub-process. The expected name can be found in the output element of the sub-process, and as you can see above, we’ve named our output variable toolCallResult accordingly.

     

2. Variable assignment value
   • This needs to simply take the expected variable from the tool task and add it to a new variable that can be put into the toolCallResult object

So in the end the output variable assignment value should be something like this:

{ “humanAnswer” : humanAnswer}

And that’s it! Now the AI Task Agent knows about this tool, knows what it does and knows what variables are needed in order to get it running. You can repeat this process to give your AI agents access to exactly as many or as few tools as they need to get a job done. The agents will then have the context and access required to autonomously select from the tools you have provided, and you’ll be able to see exactly what choices the agent made in Operate when the task is complete.

All of this is available for you to try out in Camunda today. Learn more about how Camunda approaches agentic orchestration and get started now with a free trial here. For more on getting started with agentic AI, feel free to dig deeper into our approach to AI task agents.

The post Guide to Adding a Tool for an AI Agent appeared first on Camunda.

As developers explore how to make multi-agent systems useful and reliable, new communication standards are emerging to address the need for interoperability, security, and shared understanding. Three notable efforts in this domain are:

• Model Context Protocol (MCP) developed by Anthropic
• Agent Communication Protocol (ACP) developed by IBM Research
• Agent2Agent (A2A) Protocol developed by Google and Microsoft

Each targets a specific layer of the multi-agent interaction stack and reflects different philosophical and architectural priorities.

Model Context Protocol (MCP)

Anthropic developed the Model Context Protocol (MCP) to solve a narrow but critical problem: how to give large language models (LLMs) structured context about tools, APIs, and systems they can interact with. MCP focuses on standardizing the input context that LLMs receive before agents execute their tasks. As the Anthropic documentation says, “Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.”

With MCP, tools expose a structured schema such as an OpenAPI or JSON schema along with natural language descriptions. The LLM receives the schema via MCP when it is being prompted to act, ensuring a consistent understanding of available actions.

As an early example of agent-to-agent communication, MCP has several advantages. It has promise as a way to equip AI agents with structured context to call APIs, tools, and plugins intelligently. It’s an open specification that’s designed to work with any LLM or agentic framework, making it highly flexible. And it’s lightweight and easy for software developers to adopt because it aligns with common software development practices.

However, it’s important to note that MCP is limited to tool and model interactions; it’s not a general-purpose agent protocol. As of now, it doesn’t define inter-agent negotiation or dynamic delegation of tasks.

Example: Customer onboarding in financial services

Imagine a customer onboarding process at a retail bank, which requires validating identity documents, performing Know Your Customer (KYC) checks, interfacing with fraud detection services, and activating new customer accounts. Traditionally, each of these tasks is handled by a separate back-end service with its own API.

Using MCP, an AI-powered onboarding agent could be equipped with structured, real-time context about all of these APIs. MCP ensures the agent understands what each service does, how to call it, and what inputs and outputs to expect, without the need for a developer to hard-code specific logic into the model.

This allows the onboarding agent to dynamically compose API calls, intelligently route requests, and adapt its workflow if a service is temporarily unavailable—all while minimizing human intervention. The result is a faster, more consistent onboarding experience that reduces manual handoffs and operational delays.

Agent Communication Protocol (ACP)

The Agent Communication Protocol (ACP) developed by IBM Research is designed to define how autonomous AI agents communicate with one another, with an emphasis on structured dialogue and coordination across heterogeneous systems. It aims to provide a shared semantic foundation for multi-agent communication, including message types, intents, context markers, and response expectations.

With ACP, agents exchange structured messages that encapsulate intention, task parameters, and context. The protocol enables dynamic negotiation between agents—for example, for delegation or task refinement.

ACP’s strong focus on semantics and interoperability mean it has the potential to become a very powerful protocol for high-level coordination of agents (beyond simple messaging). It can facilitate distributed task-solving by autonomous agents that have overlapping goals.

However, a potential hurdle to adoption is that ACP requires agent developers to agree on shared ontologies. This may position it as the protocol of choice for development teams that work for the same company or that work on the same software product. ACP is still in the early stages of development in terms of syntax, implementation, and tooling, so much remains to be seen as it grows.

Example: Supply chain coordination across departments

Consider a global manufacturer with autonomous agents representing procurement, inventory, and logistics. These agents must coordinate continuously to maintain optimal stock levels, anticipate shortages, and reroute shipments when needed. Using ACP, these agents could engage in structured, semantically rich dialogue to negotiate changes in supply orders, reallocate inventory based on real-time demand forecasts, or trigger alerts if a delay will cause cascading disruptions. For example:

• The procurement agent might notify logistics: “Delay expected from supplier X. Can we reassign delivery Y?”
• The logistics agent can respond: “Yes, rerouting via warehouse Z. Updating inventory accordingly.”

By using shared ontologies and structured message types, ACP aims to support adaptive, high-fidelity inter-agent collaboration across teams and systems. This is especially valuable in environments where distributed decision-making and resilience are key.

Agent2Agent Protocol (A2A)

The Agent2Agent Protocol (A2A) being developed by Google with support from Microsoft is another open standard. It’s designed to allow different AI agents from different companies or domains to exchange messages and perform coordinated tasks. Its development was prompted by the growing use of LLM-based agents in workflows that span multiple applications.

In A2A, agents advertise their capabilities using a structured metadata format called “agent cards.” Agents then communicate through signed, structured messages based on a shared schema. A2A includes provisions for trust, routing, and structured memory exchange. This design maximizes the options for composability and cross-platform collaboration between AI agents.

While A2A is a community-driven project, it is supported by two of the largest software companies in the world, both of which are cloud providers and LLM vendors, which may accelerate its development. However, the protocol is still an early-stage alpha with evolving security and governance capabilities, making it difficult for other vendors to start developing with it.

Example: Cross-platform customer support automation

Picture a scenario where a retail company uses Google Workspace, Zendesk, Salesforce, and Microsoft Teams. Different LLM-based agents exist in each environment and perform tasks such as summarizing conversations, logging support tickets, updating customer relationship management (CRM) records, and scheduling follow-ups.

With A2A, these agents can collaborate across platforms:

• A Google-based agent summarizes a support call and shares the summary with a Salesforce agent
• The Salesforce agent updates the customer record and flags a follow-up
• A Microsoft-based assistant sees the flag and books a Teams meeting with the customer

Through agent cards and structured messaging, A2A aims to enable interoperability across agent ecosystems, so tasks can flow fluidly without brittle, point-to-point integrations. This supports consistent, personalized, and efficient customer service—at scale.

Comparing developing communication protocols

The following table summarizes the current state of MCP, ACP, and A2A:

As you can see, these three protocols represent complementary approaches to the problem of inter-agent communication. MCP addresses the immediate need to contextualize LLMs effectively; ACP looks further ahead at semantic richness and intent modeling; and A2A targets broad interoperability across agents and platforms.

For developers and organizations building agentic architectures, understanding and experimenting with these protocols will be essential. While no single standard has emerged as dominant, the collective momentum suggests that interoperability and shared context will be key to unlock the full potential of multi-agent AI.

Camunda can help you operationalize AI agents

Whether you’re new to agentic AI or you’ve already started building agents, Camunda process orchestration and automation can help you put AI into action. To learn about Camunda’s agentic orchestration capabilities, check out our guide, “Why agentic process orchestration belongs in your automation strategy.”

The post MCP, ACP, and A2A, Oh My! The Growing World of Inter-agent Communication appeared first on Camunda.

If you couldn’t join in person in Amsterdam, many sessions are streaming live and it’s free to join online—so you can still catch the action! Just register at the link below, check out the agenda and make sure you don’t miss anything (be sure to filter by livestream). We’ll see you there, whether online or in person!

Update: CamundaCon 2025 Amsterdam has ended, but you can check out the videos (when available) so you don’t miss a thing!

What’s happening right now? The morning run with Bernd and the Camunda team, followed by the unconference, platform mastery series, industry round tables and more. This post will be updated again closer to when the livestream kicks off with the opening keynote with Camunda co-founder and Chief Technologist Bernd Ruecker and Bastian Körber, VP Product Management at 12:30pm CEST / 6:30am ET. See you all then!

We’re back! Once again, congratulations to everyone who took off early today for the morning run. Well done! Including our tall friend all the way on the side there, they look like a great runner to me.

Welcome!

Camunda’s Amy Johnston returned to the stage to welcome everyone to the second day of CamundaCon 2025 Amsterdam! Once again, Amy explained the traditional Camunda Selfie Screen (the first day’s selfies are already up and on display, tag your selfies with #camundacon and #selfie to join!), the Camunda and sponsor booths, available silent disco-style demo business break presentations (listen with headphones as you grab a coffee), and of course how to access the WiFi and Slido for questions. Amy also covered our code of conduct and how you can fill out your “passport” with stickers to help us decide where charitable contributions we’ll be making will go.

Next up, she welcomed Camunda Co-founder and Chief Technologist Bernd Ruecker and Bastian Körber, Camunda’s VP of Product Management, to the stage for today’s opening keynote.

Day 2 Opening Keynote by Bernd Ruecker and Bastian Körber

Bernd and Bastian took the stage and without further adieu, Bernd declared: “theory is gray, let’s get to a live demo.” Camunda CTO Daniel Meyer had introduced the concept on stage yesterday of an AI Agent that can assist with loan generation, including by sending the user emails and much more. It’s time to see it in action.

Bernd and Bastian began by making a request for an appointment and demonstrated how the bot replied, including with a specific request to request three timeslots for an appointment—which only required a very simple natural language request in the element documentation in your BPMN.

For particularly tricky cases, of course, the AI Agent will consult a human expert. However, the AI Agent is self-learning, which means after you tell it how to handle a given situation, it will learn from that experience and eventually no longer need to ask an expert about it. Bastian noted that this actually makes a live demo a bit tricky, because if you test out the demo environment to make sure it’s working, well, you can’t ask that question again live! Fortunately, Bernd was able to give the Agent a tricky situation about an unfortunate conference speaker who just lost his job.

Bernd then noted that this had only been a live demo so far, what about livehacking? So he added a task to greet CamundaCon with every response going forward. As part of this demo, they also displayed Camunda’s new RPA capabilities in action, showcased how Optimize can be used to help you understand your process and understand costs, and much more. If you couldn’t see it live, don’t miss the recording to see all of this working live on stage.

Zooming out a bit, Bastian then talked about the power of Camunda’s ad-hoc sub-process, explaining why Camunda believes AI Agents thrive within BPMN and function better that way than as purely standalone agents (which is how many organizations are implementing AI). He explained that there are four primary capabilities that the Camunda Agent has—the LLM of course, but also memory, tool access, and critical guardrails.

Bernd highlighted the flexibility of Camunda’s approach. Not only can you adopt many different patterns, including multi-agent orchestration (a tool can be an agent itself, and parent agents can coordinate globally while sub-agents plan locally), but you also have the ability to customize as much or as little as you want based on the needs and skills that are in play. Pro-code, no-code, and everything in between—you choose. This is the multi-layer coding experience.

When it comes to Camunda’s approach to AI Agents, Bastian noted that Camunda generally advises to “use workflows when possible, and agents only when necessary.” He also explained the benefits of creating the “deterministic sandwich,” where you have specific flows before and after the agents operate, so you can best control and understand their actions.

Bastian and Bernd closed by highlighting the upcoming Camunda 8.8 release, which includes features like the FEEL copilot, greatly simplified installation and much more. They also displayed the email AI Agent blueprint that is available today and runs on the latest Camunda alpha that was released two days ago—so you can play around with it today.

There was a lot to take in from this keynote, so be sure to check out the whole recording to dig deeper when the videos are shared soon! And don’t forget to check out a new book Bernd co-authored recently, Enterprise Process Orchestration (attendees can grab a copy on site).

Guest Keynote: Four Lenses to Make Process Orchestration and AI Work

Bernhard Schaffrik, Principal Analyst at Forrester was invited to the stage next to give his perspective on how AI is being used today. He led off with a glimpse of a utopian future of what AI can do—where we’re all sitting around sipping drinks while the AI does all the work—but we’re not getting there anytime soon. In the meantime, companies have been experimenting boldly with AI in 2024, noting that he had just about no conversations with business leaders that did not touch on it. This experimentation will only continue.

Schaffrik shared a prediction that in 2025 25% of automation projects will combine cognitive and physical automation—or in other words, robots. He gave an example of supermarket upstocking, which now is largely manual, but which can be further automated with the use of a robot. Generative AI will help robotics move past high-volume, low-skill operations and into more complex interactions since they are better at understanding ambiguity.

Another prediction was that in 2025, only 1% of core processes will run on generative AI. Why? There is still too large of a trust gap. That means deterministic orchestration will still be in charge through this year and that the world where generative AI makes these critical unstructured decisions will have to wait. Schaffrik also identified siloed work as a damper on efficiency, and noted that process orchestration is a fantastic way to break these down.

So how do we get to the future where we are maximixing Agentic AI? There are four lenses that Schaffrik wanted to share to help us understand this question.

Thinking about the value of an AI more than just the cost—treating your AI agents like new hires that you have to onboard, coach and train, but who will deliver huge value over time. Knowing when to use AI and not trying to put it everywhere. Breaking down data silos to unlock AI’s strengths. Solving the trust gap with a blend of deterministic and non-deterministic approaches. These are all fascinating layers to examine when incorporating AI into your workflows.

Schaffrik closed with a quotation from Jamiroquai, a 90s UK band with a song called “Virtual Insanity.” The quote was essentially about how we need to make the future work for us, and not against us. This may require a trip to YouTube for more research! A great thoughtful talk with some very helpful Q&A at the end.

AI Agents and BPMN: Orchestrating the Predictable and the Unpredictable

Bastian rejoined us on the stage to dive deeper into how we can use AI Agents and BPMN to generate value today and in the future. Many people are asking whether it’s time to shift to a fully autonomous world, or are we not ready yet and we need to stay in the reliable deterministic world we know? The answer is that it’s not an either/or choice—it’s better together.

Bastian emphasized that AI Agents thrive in BPMN, not as standalone apps. “We’re not there yet,” Bastian noted. As Bernhard Schaffrik noted earlier, only 1% of core processes will rely on generative AI in 2025. The way to get real-world value today with agentic orchestration is with a blend of deterministic and dynamic orchestration.

Observability is key for building trust and enabling AI to be involved in important processes today. In Operate, Camunda already provides an end-to-end trace tree and zero-downtime fixes, and through Optimize, you can build dashboards to help you understand your costs and bottlenecks. With BPMN and Camunda, you can trust that you know what your AI Agents have been doing, which is not only critical for audits and compliance but also for training and improving.

Bastian spoke about new connectors that Camunda recently debuted that enable AI Agents to operate and have a long-term memory, and you can explore these today, but he cautioned that AI is not magic. Think first, code later. Design thoughtfully, including with a “guardrail sandwich” that surrounds an agent with a deterministic task on one side and deterministic validation on the other. There were many other key points here, all great things to think about. Check them out and hear the Q&A in the full presentation.

ICYMI

• Climbing the Mountain: How LBBW is Achieving Digital Transformation via Enterprise Process Orchestration, Benjamin Fürnrohr, Senior Consultant at Novatec Consulting (now part of CGI) and Nils Kaufmann, Head of Process Automation at LBBW led this session about how LBBW (Germany’s sixth-largest bank) began its journey towards Enterprise Process Orchestration along with Novatec Consulting. Gain insights into LBBW’s journey toward Digital Transformation and see how Camunda 8 will play a key role in the company’s plans going forward.

Clearstream: Orchestrating D7 Digital Securities Services supported by Camunda

Next up, Julia Blankenberg, Head of Cloud Office, Tools & Orchestration at at Clearstream, and Jürgen Witzel, Project Manager at Deutsche Börse AG joined us to talk the next step in the digital transformation of the Germany-based trading marketplace. Witzel spoke about how the progress for the exchange is much like that in other industries, moving from in-person only to becoming increasingly digitally accessible.

D7 is an improved way for Deutsche Börse AG to offer institutional-grade market digital and tokenized securities insurance. Clearstream processes over 1 million transactions daily with funds from 55 countries. These are large, high volume, global and highly regulated areas—the complexity involved goes without saying. Digital issuance of securities on using D7 is growing rapidly and scalability and security are critical.

Blankenberg then spoke to more of the technical details, describing their decision to change over time from a choreography-based approach to a microservices orchestration approach with Camunda at the center. This gave them end-to-end process visibility, as well as improving the ability to monitor SLAs, discover issues, improve customer service and have a faster time to market. Witzel emphasized that they also now use Camunda Modeler to model all D7 processes end-to-end, including legacy interactions, which is a huge added benefit.

The roadmap for future improvements includes expanding to other European markets, incorporating blockchain transactions (the DLT solution pictured above), and more. Check out this full talk to learn more about how Camunda 8 has played a critical role in helping this financial services organization grow and provide better service to their customers.

ICYMI

• How British Telecom’s next-generation broadcast network relies on Camunda – Ajit Dani, Principal Solutions Architect and Shunxiang Yao, Senior Software Engineer at BT Group talk about the development of Vena, BT’s next-generation service delivery platform for broadcast video distribution in the UK. Vena was created to provide best-in-class performance for media traffic, and to empower customers to self-serve. See why British Telecom relies on Camunda to power Vena, and dive into the benefits of process orchestration and automation for the organization and its customers.

Business Breaks

Next up for our in-person guests, we have our silent disco-style Business Breaks: Powering the digital factory: How Camunda 8 supports Sonepar through checkout process orchestration with Mohamed Elhabib, Solution Architect at Publicus Sapient and Samrawit Yoseph, Director – Product Owner Lead at Sonepar, and Supercharging process discovery with AI-powered landscapes with Eric Lundberg, Senior Product Manager at Camunda.

For our online readers, this is a good chance to stretch your legs. We’ll see you back here shortly!

Transforming digital banking processes with orchestration and automation using Camunda 8

Yuvraj Keenoo, Tech Lead and Bholanathsingh Surajbali, Engineering Lead at MCB (Mauritius Commercial Bank) took the stage next. MCB is a multi-national bank operating in 10 countries with over a million customers. Keenoo started by asking what it would look like if every interaction was automated but also every decision was made in real time? How would that make you feel? Little by little, he said, we are getting there and working towards that.

What was holding MCP back from that today? Surajbali and Keenoo noted several issues: lots of siloed processes with no visibility, time consuming identity verification, disconnected systems with lots of manual work and compliance challenges. To lay the foundation for change, they focused on customer experience. Goals included improving turnaround times, the need to be digital and scalable and omnichannel, as well as compliance and risk reduction. They set business goals of providing 24×7 self-service options, quicker response times and scalability.

Keenoo laid out their goals with hyperautomation, with an orchestration layer connecting numerous critical tasks throughout the system. It’s an excellent vision, but as Surajbali noted, it couldn’t all be done at once. They needed to go step by step.

Surajbali went on to explain how a number of microservices, orchestrated by Camunda, can now communicate with APIs, RPA and IDP to greatly enhance a number of key processes. They walked through four use cases in some detail, including onboarding, document classification, faster processing of high-volume documents and account to account transfers.

The results? A huge decrease in onboarding time thanks to IDP (from 70 minutes to 25 minutes), a frictionless digital submission process for users, and a 64% reduction in employee processing time per application. Overall, as they note, “automation is a journey – it’s about constantly evolving and improving.” Their big message to anyone who has not yet embraced automation is to just get started somewhere. Be sure to watch this video to see some innovative examples of automation that are delivering real value in a complex market.

ICYMI

• Empowering Automation: Smarter Orchestration with Camunda – Discover how Camunda’s business orchestration and automation technologies are enhancing task automation. Calvin Robbins, Senior Manager, Product Management and Sahil Bhatoa, Senior Software Engineer – Full Stack at Camunda explore how IDP and RPA integrate seamlessly into Camunda’s platform, driving faster and smarter end-to-end workflows and streamlining automation.

Fireside Chat & Closing

Finally, Amy welcomed Jakob and Bernd to the stage for what will be the final time (how are we already here?). She opened the conversation by asking Jakob about the overall impressions they’ve been hearing about everything Camunda has debuted around agentic orchestration? Jakob said he’s never experienced how much interest he’s seeing right away around agentic orchestration. In the past, it tended to take some education over time but this is really different—the value is obvious. He wasn’t hearing questions about whether companies want it, it’s more about how we can implement it safely and successfully. The feedback on how we’re going about it has always been very positive, particularly the blend of dynamic and deterministic by blending BPMN with ad-hoc sub-process. It just doesn’t exist anywhere else and it’s exciting to hear that from other people.

Amy noted that she was glad organizations were valuing this approach, she wants her bank and healthcare companies to be cautious and not just hand everything to AI. Bernd noted that it reminded him of the early embrace of microservices. Technologies like this aren’t magic solutions to everything, but with the correct orchestration, they can accomplish a tremendous amount.

Bernd reflected that he really enjoyed seeing the developers in the hackday—there were 81 of them!—were building agents in a fun and playful way and seemed to be enjoying the process. He appreciated that people seemed to be understanding not just the why but the how of building AI agents. Amy added that she thought it was so cool that everyone was using a technology that we literally announced two days ago, which is not something that all vendors can say—you can really use what we announce, even the alphas.

Jakob also highlighted that the embrace of recently released features such as IDP and RPA has also been excitingly strong, with dozens of companies already deploying them to production only a few weeks after they became GA in April. Since Camunda typically orchestrates mission-critical processes there is often a slower adoption period, but the backbone of orchestration seems to be helping companies incorporate some of these new additions faster than ever before. The momentum is incredible.

As for final takeaways, Bernd recommended people check out the blueprints and just get started and play around to see how the new additions can help you. He also summed up CamundaCon in two words: Energy and enthusaism. Jakob was excited to see the adoption by both business and IT and thanked everyone for attending and also all Camundi who helped make today happen.

Thanks for coming!

Thank you to everyone who attended and helped make today happen! Your smiling faces in the selfie wall are a sight to behold (and don’t worry, there’s still time to tag your #camundacon #selfie photos!). For anyone who couldn’t join or who missed a session they wish they could have attended, be on the lookout for the video recordings of the talks to come out next week.

See you next time in New York!

That’s it for CamundaCon 2025 Amsterdam! CamundaCon returns on October 7th and 8th in New York City! Don’t forget to register now, and we’ll see you there!

The post CamundaCon 2025 Amsterdam Day 2 Live Blog appeared first on Camunda.

We’ve seen time and time again that task-based automation might deliver quick wins, but it doesn’t scale. The moment processes get complex, those isolated tools start pulling in different directions. The result? Broken customer experiences. Inefficient teams. A lack of visibility and an inability to improve processes.

That’s the problem we set out to solve back in 2013. And it’s the same problem we continue to solve—only now, the stakes are higher.

AI is changing everything. Nearly every conversation we’re having with customers right now touches on it. According to the 2025 State of Process Orchestration and Automation Report, 84% of organizations want to add more AI capabilities over the next three years. But 85% struggle to make AI actually work at scale.

There are a few reasons why this is happening. First, simply adding AI into an automation strategy doesn’t magically create value. Done incorrectly, it just creates another silo—and yet another layer of technical debt. 

Second, traditional process automation focuses on automating around a set of predetermined rules (or deterministic orchestration). AI presents the opportunity to break those rules by executing processes dynamically.

That’s where agentic orchestration comes in.

Overcoming limitations in traditional process design

Process orchestration as we know it is deterministic, meaning you design processes and define their logic in advance. Sure, it can handle variants, but only if they’re a part of the original process model in BPMN or DMN. What we think of today as a fully automated process, or “straight through processing” (STP), usually relies on this structure.

AI agents make process automation much more dynamic. Dynamic orchestration uses AI to handle “unforeseen” tasks. It orchestrates based on defined goals and a given context, but doesn’t need specific instructions like a deterministic process.

But most business processes are somewhere in the middle. They have some STP in place, but are still using human case management to handle exceptions or tasks without a straightforward action. Agentic orchestration blends deterministic and dynamic orchestration seamlessly.

For example, most of the time, STP is done in seconds or minutes. But sometimes it fails. And when it does, people step in to investigate. It’s slow, messy, and manual. That’s where AI can help. Agentic orchestration takes over when the unexpected happens—analyzing unstructured data, spotting patterns, and suggesting actions.

Real world examples of agentic orchestration

And here’s where things get really exciting: This isn’t theoretical anymore. It’s real. It’s working. And it’s already creating serious value.

Our partner EY has built a tool for agentic trade reconciliation with Camunda. Reconciliation errors are usually handled manually. Because they are very labor intensive, they take a lot of time to review and are error-prone—resulting in a risk of fines. In fact, the world’s largest banks employ up to 25,000 people to review these exceptions. With agentic orchestration, they’re now using AI to suggest the next best action based on trade data and LLMs. That means faster resolution and T+1 compliance. But the most impressive value is in productivity: With agentic trade reconciliation, one employee can now handle far more cases per day on average, resulting in an increase in productivity of 7x.

Here’s another example: Payter, a payment terminal business for vending machines, is drowning in case management when payments fail. They have now started using Camunda to blend deterministic process logic with AI agent-driven exception handling. The expected outcome? Resolution times will drop by 50% from 24 to 12 minutes. Even better? Customer service will improve not just because of the shorter resolution time, but also because employees are now able to spend more time on complex issues.

Building the autonomous organization of the future

And the examples above are only the beginning. We’re seeing more and more companies wanting to bring more AI into their processes. In order to do that, they’re operationalizing AI in a way that’s composable, scalable, and flexible—not stuck in isolated systems. And Camunda is at the foundation of this shift. We’ve spent over a decade building a platform that does one thing exceptionally well: orchestrate complex, mission-critical processes from end to end.

Now, we’ve taken our powerful orchestration engine and infused it with embedded AI. The result? The ability to blend deterministic and dynamic orchestration in a unified agentic orchestration model—with guardrails, auditability, and control.

What does that mean in practice?

It means you can now:

• Blend structured BPMN and DMN process modeling with flexible AI agents.
• Automate what was once “un-automatable” (like complex case management).
• Inject AI into your legacy systems without a big bang transformation.
• Use low-code tools and connectors to move fast.
• Implement AI safely and reliably, with “guardrails” for full auditability and control.

We’re giving you AI-native capabilities, like:

• Ad-hoc sub-processes: Let agents decide what happens next.
• Camunda Copilot: Go from a text prompt to a running process.
• RPA and IDP: Integrated, out-of-the-box, and ready to go.
• ERP Integration: Orchestrate AI across SAP, ServiceNow and beyond.

Here’s a look into the future: AI agents that get even smarter by working alongside humans—automating more and more over time. Think AI loan specialists that are trained directly from human input.

Our long-term vision hasn’t changed

We’ve always believed in end-to-end process orchestration. What’s different now is how far we can take it. Agentic orchestration brings us closer to a world where AI and humans truly collaborate across systems, teams, and time zones. We’re designing the autonomous, AI-powered organization of the future.

If you’re thinking about bringing agents into your business—this is the moment. With Camunda, you’ve got the foundational technology and the vision to do it right.

The next chapter of automation just started. And I couldn’t be more excited.

Let’s build the future together.

Learn more

You can learn more about our agentic orchestration capabilities here, and if you want to dive deeper, be sure to watch the recording of the keynote from CamundaCon 2025 Amsterdam (available soon).

The post Agentic Orchestration: Automation’s Next Big Shift appeared first on Camunda.

We hope you’re as amped up as we are for CamundaCon 2025 Amsterdam—the first time CamundaCon has ever been to this great city—which kicks off online in mere minutes! Just like at the previous CamundaCon in New York City, we’ll be bringing you the latest updates from the event live as they’re happening. Be sure to check back frequently as we’ll be updating this post throughout the day.

If you couldn’t join in person in Amsterdam, many sessions are streaming live and it’s free to join online—so you can still catch the action! Just register at the link below, check out the agenda and make sure you don’t miss anything (be sure to filter by livestream). We’ll see you there, whether online or in person!

Update: CamundaCon 2025 Amsterdam has ended, but you can check out the videos (when available) so you don’t miss a thing!

The hackday and live masterclasses taking place in person in Amsterdam will be wrapping up shortly. The main event begins with the opening keynote at 12:30pm CEST / 6:30am ET. Stay tuned for more updates here!

For those of you at the hackday, you may have caught a glimpse of this svelte gentleman working the room. As always, Niall is here to help.

The countdown is on! Get excited, we’re about to begin here in Amsterdam.

Welcome!

Camunda’s Amy Johnston welcome everyone to CamundaCon 2025 Amsterdam! Excited to be in Amsterdam for the first time in a historic building, Amy explained the traditional Camunda Selfie Screen (tag your selfies with #camundacon and #selfie to join!), the Camunda and sponsor booths, available silent disco-style demo presentations (listen with headphones as you grab a coffee), and of course how to access the WiFi and Slido for questions. Amy also covered our code of conduct and how you can fill out your “passport” with stickers to help us decide where charitable contributions we’ll be making will go.

Next up, she welcomed Camunda co-founder and CEO Jakob Freund to the stage.

Opening Keynote by Jakob Freund

Jakob led off by thanking the absolutely packed room you can see above for attending, and then taking us through a brief history of the evolution of process automation. Essentially, in the early days, task automation was isolated and local, and created a value trap—quick wins that ended up leading to technical debt when organizations tried to modernize and eventually orchestrate the whole process.

Agentic orchestration

Camunda has always been about breaking you out of that value trap with end-to-end orchestration, and with the new ability to incorporate dynamic orchestration we can now take that approach much further. By combining deterministic orchestration (straight through with predefined rules) with dynamic orchestration (which is less structured and where an AI agent can make decisions), you get something new: agentic orchestration.

Trade reconciliation and the challenge of T+1

Jakob then invited Lars Tandrup, Partner/Principal at our partner EY, to talk about a solution to a difficult problem in financial services—reconciliation of trades. New regulations in the US mean this has to happen within 24 hours, and many companies have tens of thousands employees dedicated to tackling this manually today. Implementing agentic orchestration delivered a seven-fold (wow!) increase in the ability of users to handle trade reconciliations, and a 98% reduction in cases that go beyond T+1 (and would incur fines for being too slow). This is a powerful story, and Lars will be talking on a live streamed session later today to dig in deeper, definitely won’t be missing that one.

How agentic orchestration works in Camunda

Daniel Meyer, Camunda’s CTO, then took the stage to showcase a little more of how agentic orchestration works behind the scenes. Dynamic orchestration is realized by agents and can change—which is different than simply incorporating AI into a deterministic process. In screenshots from a demo (which will be shown live tomorrow!), he explained how easily an LLM could, for example, send emails automatically based on unstructured user requests. But he also demonstrated the value of BPMN in how easily you could simply add a user task before the email goes out if you want a human to review first.

Then Daniel posed the question—so is there still a place for deterministic, straight-through processes? The answer is a resounding yes. For example, SIM card activation is a critical process for telecommunication companies, and the standard is that it is routinely completed in less than one minute. This is not a candidate for dynamic orchestration. However, exception handling is still a problem. When something goes wrong, the usual procedure is to kick out to a manual check. This is an agentic orchestration opportunity where it can still help.

Other examples

Several other speakers than demonstrated some fascinating examples. Andre Bal, Director of Supply Chain and Automation at Payter recently partnered with Edwin Nooijen, Partner Manager at Incentro to use agentic orchestration to reduce the workload for the humans and dramatically improve the service level to customers. Dr. Leander Fielder from NordLB spoke to how they created essentially an center of excellence for AI and realized the value of combining deterministic processes with dynamic processes along with humans in the loop to provide guardrails for AI. These are exciting stories of agentic orchestration already being used in the market today.

Don’t wait

Jakob’s final message was not to wait. The autonomous enterprise of the future is coming, and agentic orchestration is not a pie in the sky. It’s here, today, and it’s only becoming more and more common and more powerful. Look into it, talk to us, and let’s see what we can do together.

Reinventing Fraud Detection: NatWest’s Journey to Operationalize AI with Camunda

Joanne Barry, Head of Technology Fraud Prevention COE at NatWest and Milesh Chudasama, Digital Transformation Director at NatWest then talked about how NatWest is operationalizing AI for fraud detection and more. Milesh talked about the importance of an “opti-channel” mindset (rather than omni-channel), helping the customer to always get to the right channel at the right time.

Innovation by Cooperation | Rabobank’s approach on banking for the future

Fred van Pouderoijen, Head of Tech Payments & Savings at Rabobank next took the stage to talk about how they are using AI today. From copilots and chatbots for software development, operational efficiency, and customer service and more, Fred spoke about the benefits they are seeing today. In the future he sees a huge opportunity in using it to assist with anti-money laundering and KYC, as well as financial advising.

How HSBC redefines the customer journeys at scale with Camunda

Dan Avidan, Lead Platform Architect at HSBC was up next to talk about how HSBC worked to improve their customer journey flow with process orchestration at a massive scale. HSBC is a large and global bank, with over $3 trillion in assets, over 41 million customers, and operating in 58 markets. Avidan took us through the complexity of their legacy structure and the challenge of needing to scale across a large global market.

A key goal was empowering the business to do everything from designing, to monitoring, to optimizing and more. Avidan spoke about how two value stream use cases are already live with Camunda (with four more coming this year), how they have enabled BPMN usage across the company, and the infrastructure they have put into place to handle it. He also shared a lot of lessons learned, food for thought, and excitement around upgrading to 8.8 soon. Check out the full recording to see how a large, complex and highly regulated environment was able to simplify and gain huge efficiencies using Camunda.

ICYMI

• From Zero to Traffic: Rolling out carrier network with Swisscom and Camunda – Swisscom transports the major share of Switzerland’s internet traffic. In this session, which was not streamed but will have a recording available after the event (be sure to sign up to receive the link!), you’ll learn about both the high-level business processes, the low-level hardware requirements, and how Camunda was adopted by developers within the company.
• Hackday Presentations – These were also taking place along with the two talks above. While they are not recorded, in-person attendees were treated to many fine presentations as always, and we hope online readers enjoyed a taste of what the hackday was like above.

Digital transformation at Halkbank: Enhancing operational efficiency & customer experience with Camunda

The next session was led by Gülefşan Yildirim Başaran, Unit Manager, Core Banking Software Development at Halkbank and Ibrahim Küp, Senior Software Developer at Halkbank. Halfbank is among the largest banks in Turkiye, with 18 million customers, 23,0000 employees and over 1,000 branches. Başaran explained that, as with their peers in the industry, they are facing challenges such as rising transaction volumes, evolving customer expectations, and rapidly changing regulations. Halkbank is using Camunda as a critical platform for solving these challenges.

Küp went on to talk more about the challenges they had with their legacy systems and their efforts to digitally transform. Went it came to a process orchestration solution, they had key requirements, including following open standards, transparency, strong performance and the ability to operate in harmony with their existing Anka framework. Camunda was the solution that met these requirements, including the ability to work with a highly customized taskpool application.

Money transfers are critical for banks but to come with challenges. Başaran detailed the process behind the 50,000 money transfer transactions Halkbank receives daily, the difficulties they have and how they resolve them. Using Camunda and AI, they were able to achieve some impressive results (see below), with 60% of transactions now completed with no human correction.

Başaran next shared some key takeaways, including that BPM is not a one-step journey and the benefits of improved business-IT integration. Küp closed the session with an overview of their migration plans to Camunda 8, which they are excited to do to gain horizontal scalability and handle higher volumes with faster response times.

ICYMI

• Scaling with Process Orchestration: Building a SAFe operating model with Camunda – In this session (not streamed but recorded), Learn how CityFibre and BP3 built a scaled agile framework (SAFe) IT operating model and integrated Camunda, which along with a CoE enabled them to scale effectively while enhancing operational agility and helping businesses thrive in fast-paced environments.

Business breaks

Next up for our in-person guests, we have our silent disco-style Business Breaks: Keeping Secrets: Mastering Secure Process Automation at Scale With Vault by Stefan Schultz and New Harbour: Transitioning Dutch pensions with Tiese Barrell and David Klein. For our online readers, this is a good chance to stretch your legs. We’ll see you back here shortly!

Tracking T-Systems Austria’s journey to Camunda 8 with myProcess Automation Platform

Lukas Fröhlich, Teamlead Automation at T-Systems and Mohamed Aly, Senior Solution Architect and Backend Developer at T-Systems joined us next to talk about their migration path to Camunda 8. T-Systems Austria is a subsidiary of T-Systems, a very large global IT services provider. In 2024 they had about 60,000 processes started and around 220 process definitions on Camunda 7 being managed by an automation team of 8, but there were many advantages to upgrading to Camunda 8—like the unified REST API, for example—and the team was eager to get started.

Aly spoke about how the initial approach—to migrate all processes and then turn off Camunda 7—was complicated due to the number of running processes they had in place. So they made the decision to run the two in parallel, enabling them to move faster and more safely by going one process at a time. Aly went on to describe various challenges in terms of infrastructure, versioning, topic limitations and more and how they overcame them. He also took us through the implementation in detail, including working with alpha versions and help received from Camunda support. Helpfully, the slides featured the month that each step was taken, giving us a great sense of the timeline here.

Fröhlich then led us through the final steps for the migration, including how they selected a meaningful use case to migrate and a demo that provides insight into how the use case is actually running in parallel and how it works in practice. While this is using an alpha version for now, he concluded with their plans to go to production with the next major release of Camunda in October, converting use case by use case (in the slide above, the use cases are moving to the right).

The Q&A session for this one had a lot of great questions as well. Don’t miss the full recording of this one for some amazing insights.

ICYMI

• Catching thieves with Camunda: A Rabobank FEC Tech story. In this session (not streamed, but recorded), you’ll learn how Rabobank uses Camunda to orchestrate key security processes in order to successfully fight financial crime and protect the bank’s customers and stakeholders. You’ll explore a crime-fighting process from inception to production.

Fast-Tracking Growth: Danica’s Digital Journey in Pension & Insurance with Camunda

Danica, which is a subsidiary of Danske Bank with over 750,000 customers, was looking to embrace more automation and speed up its growth. Janus Kierkegaard, Head of Business Process Transformation at Danica, and Lee Kiew Seng, Head of Orchestration & Integration at Danica, took us through their story. A particular challenge they faced was a high level of demand every year on January 1st, which resulted in a large backlog that took them months to clear out. This was not an ideal customer experience and something they turned to Camunda to address.

Kierkegaard started by talking about the business problems, and how a big part of the solution was not just the technology, but about explaining the value Camunda could provide and getting other departments fully on board. This includes gaining a full understanding of existing business rules and processes and how they can be simplified and improved. They took it step by step and it got easier as they went (be sure to check out the slick Lego animation in the slides that demonstrates this ).

Lee Kiew Seng then explained on a more technical level some of the advantages Camunda provided them. I can’t capture them all here, but there are quite a few fascinating slides and demonstrations of the BPMN flow in action, so don’t forget to check out the full recording to see the full details.

And what’s next for Danica? They want to reimagine the health care and claim process target solution with Camunda and AI. They’re excited for the impact this can have in 2025 and beyond. They also shared their lessons learned from both the business and IT side. There are sure to be helpful insights in this talk no matter your role.

ICYMI

• Navigating a complex transition: Migrating business workflows from Camunda 7 to Camunda 8 in financial services – Marcin Osiecki, Senior Director / Distinguished Engineer at BNY, explained challenges faced when migrating workflows from Camunda 7 to Camunda 8 in a highly regulated industry like financial services. See how BNY met these challenges to support long-running processes, meet audit requirements, and provide resiliency and reliability. If you weren’t there in person, don’t miss the recording of this event.

Elevating Agentic Orchestration: How Camunda Partners Address Real-World Challenges

Frederic Meier, SVP, Sales at Camunda led off the next session by recapping the importance of agentic orchestration and how it can address concerns around using AI in truly critical processes by providing guardrails to help harness the dynamic value of AI. He then announced the launch of a programmatic approach to release new agentic orchestration solutions co-built by partners quickly. He invited all partners to participate and was excited to showcase several in this talk.

Frederic welcomed Erwin van der Horst, Northern Europe Commercial Leader, Process Orchestration and Enterprise Integration at Cognizant, to the stage next to talk about a solution that Cognizant has delivered for agentic AI-assisted quality auditing. Previously, auditing a support would 138 minutes per audit on average. A demo showed how this time can be reduced to 8 minutes per call, allowing for full auditing of calls rather than the spot-checking that is currently standard practice. He cited a 40-60% reduction in audit cycle time, 20-30% increase in auditor productivity and 30-50% reduction in overall costs.

David Brakoniecki, Chief Delivery Officer at BP3 joined us next to talk about how agentic AI can impact compliance monitoring use cases by taking the example of Health Care Professional meetings. He talked about the challenges of compliance, which is often underfunded despite the growing complexity of the compliance landscape—at least, until there is a costly issue. It is also extremely manual and expensive. Brakoniecki highlighted how AI (paired with guardrails around DMN/BPMN) can get us from auditing a sample to true monitoring, and take a lot of low-value work off the hands of expensive compliance officers.

Next up, Edwin Nooijen, Partner Manager at Incentro, took the stage to talk about Payter’s unattended payment terminals (which was touched on back in the keynote) and how Incentro was able to help them. This included a great video demo (pictured in the keynote) showing how they significantly decreased time spent by customer support on each problem, and significantly sped up the time to a response at the same time, leading to vastly improved customer service and NPS values (not to mention happier employees).

Lars Tandrup, Partner/Principal at EY stepped up next to discuss the solution EY has built using agentic orchestration to make trade reconciliation easier and faster. This is also a solution that was touched on back in the keynote, and Lars was excited to be able go into more detail here. The reconciliation process right now is extremely manual, and employees tasked with this typically only resolve 6-10 cases per day. EY reimagined the process to see how much manual work you could pass off to an AI agent, shifting the majority of the process (see the center swimlane in the slide) away from manual user tasks towards automation. The result is a 7x boost in the number of cases an employee can handle and a huge drop in costly errors.

ICYMI

• Streamlined impact: Building and maintaining media supply chains with Camunda 8 – Tom Oellerich, Product Owner Media Supply Chain at ZDF Studios talked about how to navigate the complexities of international content distribution, which is crucial amidst the ever-present “Streaming Wars.” Discover how ZDF Studios builds and streamlines its cloud based media supply chain with Camunda 8, achieving flexibility and control over their program catalog while minimizing technical maintenance. Recording will be available.
• Our journey from Custom Engine to the Camunda 8 Universe – Jan Philipp Piekuszewski, IT Product Manager Business Process Automation at Hapag-Lloyd AG and Monika Sane, Process Performance Manager at Hapag-Lloyd AG spoke about the strategic journey Hapag-Lloyd is on to enhance its process automation capabilities, aiming to move from a custom-built engine to an advanced, scalable solution that extends across systems. Explore their migration path from that custom engine to Camunda, the architectural foundation built on self-hosted Camunda 8, the the business value through process analysis in Optimize, and more. Recording will be available.

Aftershow, Exhibition & Networking

That’s it for today! In-person attendees are now off to an aftershow for snacks, drinks and a chance to talk more with fellow attendees and speakers. Don’t forget to tune in tomorrow, either to the live stream or to the day two live blog (or both!). And for those of you in Amsterdam who are brave enough, don’t forget about our traditional morning run with Bernd and the Camunda Team .

If you’re in person, be sure you don’t miss the platform mastery series, industry round tables, the unconference and more tomorrow morning (local time) before the livestream kicks off with the keynote from Camunda co-founder and Chief Technologist Bernd Ruecker and Bastian Körber, VP Product Management at 12:30pm CEST / 6:30am ET. See you all then!

Update: CamundaCon 2025 Amsterdam has ended, but you can check out the videos (when available) so you don’t miss a thing!

The post CamundaCon 2025 Amsterdam Day 1 Live Blog appeared first on Camunda.