With the introduction of agentic capabilities into integration platforms such as Azure Logic Apps, we have seen a growing number of articles claiming the emergence of non-deterministic integration.
The idea is easy to understand. Instead of defining the complete integration flow up front, we introduce an agent that can observe, reason, make a plan, take an action, observe the result, adjust the plan, and continue until it reaches its goal.
This is certainly a new and interesting capability for integration platforms. But does it really mean that integration itself is becoming non-deterministic?
I don’t believe that’s the case.
Integration and non-determinism
Some of the discussion around agentic integration can be misleading because it mixes two distinct concerns: the experience that determines what should happen and the integration capabilities that make it happen reliably.The core responsibilities of enterprise integration have not changed.
We still need:
- reliable contracts (we need a predictable agreement on what data and operations mean, regardless of who or what invokes them).
- durable messaging (messages and events must persist even when a consumer, agent, or downstream system is unavailable, suspended, or awaiting input).
- idempotency (a replanning must not accidentally execute the same business operation twice).
- transactional boundaries (critical processes still need clear consistency guarantees, even when the decision to initiate them came from an agent).
- retries and compensation (distributed operations will still certainly fail, and we need predictable ways to recover)
- and more …
Whether the consumer of these capabilities is a web app, a workflow, a long-running business process, or an AI agent does not fundamentally change these requirements.
💡 If an agent decides that a purchase order needs to be created in SAP, the decision might have been non-deterministic.
👉 The contract and guarantees for creating that purchase order should remain predictable.
💡 If an agent decides that a customer needs to be notified, the reasoning behind that decision might be non-deterministic.
👉 The delivery of that message should still provide the reliability guarantees required by the business.
This distinction is critical: The experience can be non-deterministic. The integration layer should not be.
What agents introduce is a new way to consume and orchestrate integration capabilities. A new experience on top of established integration patterns. The sequence is no longer necessarily known at design time, but the capabilities selected by the agent can (especially in enterprise environments) remain predictable, governed integration capabilities.
One useful way to look at this is through the API-led connectivity model popularized by MuleSoft.
Agentic systems fit surprisingly well into this way of thinking. An agent can become part of a new, intelligent experience layer.
Instead of exposing a predefined experience for every scenario, the agent can interpret the user’s intent, reason about the goal, and dynamically decide which capabilities are required.
Underneath, however, the enterprise integration foundation remains. The agent does not replace integration. It consumes integration capabilities differently.
The tools give agents capabilities
There is, however, an important architectural change introduced by agents: well-designed tools become the boundary between non-deterministic reasoning and predictable execution.
An agent might reason: I need to check the customer’s account, verify whether the invoice has been paid, and potentially open a support case.
But the agent should decide what needs to be done, not invent how the integration with enterprise systems should work.Instead, we expose well-defined and governed capabilities that the agent can discover and invoke. Behind those capabilities, the integration layer continues to provide the contracts, security, reliability, and business rules required to execute the operation safely.
In other words: The agent decides what to do. The integration platform controls how it is done, ensuring it is done safely and reliably.
Azure Integration Services: moving up the stack
This is where platforms such as Azure Logic Apps become particularly interesting. Logic Apps (and the whole Azure Integration Services family), has effectively expanded up the stack. In addition to its established role in deterministic workflows and enterprise integration, it can now participate directly in the agentic experience layer.
Does that mean we now need to build non-deterministic integrations? No. It means the platform we already know has gained new capabilities.
We can continue using Logic Apps to build strong, predictable workflows with well-defined contracts and rules, while using its agentic runtime capabilities to safely expose enterprise capabilities to agents, with the controls, governance, and observability they require.
And that is the interesting part: we don’t need to reinvent enterprise integration for the AI era. We can use the foundation we already have to drive AI adoption and build the next generation of agentic experiences.
TL;DR
Keep your integration layer solid and deterministic, and you can let your AI agents run wild with creative problem-solving without breaking the enterprise !!
Read the original blog post here: Agentic Integration: Non-Deterministic Experience, Solid Core
Subscribe to our RSS feed