Concurrent Agentic Orchestration with Pega

In this article, we explore how a concurrent agentic orchestration pattern can be achieved within Pega. Before diving in, a word of advice: check whether the use case really needs a fully agentic flow or whether a Pega workflow is enough. In my experience, most enterprises will still need Pega workflow for concurrent orchestrations too.

Let’s first look at what concurrent agent orchestration pattern is. As a reference I am going to use a definition from Microsoft Azure architecture patterns.

In this pattern, multiple AI agents run concurrently (obviously) on the same task. In this way, each agent can take their own unique path in the research using their strengths and specialisations in certain areas. This approach has several benefits over the sequential agentic design pattern, the most important being saving processing time. However, the most important thing here will also be the ability to consolidate the results.

With a fully agentic design pattern you will need to build a mechanism to consolidate these results, but (spoiler alert!) Pega has that already built in. Now let me explain how this pattern can work with Pega.

Let’s think of a hypothetical scenario: Investment Research at an investment agency. This scenario is much more real than it sounds, since most organisations do this kind of work.

There are two ways to implement it. If you have a fully agentic architecture, you could have, let’s say, one Initiator agent that splits the work across three different agents, each handling a different type of research.

For example, one agent may run the fundamental checks on a stock, looking at the company’s financials and revenue, or handle the competitive analysis. We have another agent, let’s call it the technical agent. This agent checks price patterns, volume indicators, etc.

And let’s say we have a third agent to analyse sentiment, processing news articles, social media mentions, etc.

These three agents, along with the collaborator, can nicely fit into the agentic workflow, as we see on the left-hand side. You could have all agents store their research in one place, and then an aggregator agent will consolidate it.

Can this be done in Pega? Yes, absolutely can. And you don’t have to hand over the steering wheel to get there.

In Pega, you could configure the workflow as a Split-Join, where the task gets divided into multiple paths and the results are aggregated automatically at the join. Here you could call three different workflows, one through each branch, and have a join shape pull everything back together.

With this, your agents won’t go unchecked, and you get the full advantage of Pega’s predictable, auditable, and governable workflow. Every branch is visible, every step is logged, and nothing wanders off on a tangent.

How do you decide between fully Agentic AI vs Pega Agentic ?

Criterion Choose fully agentic Choose Pega Split-Join
Cost Hard to predict, since the agent may keep iterating Predictable: One call per branch
Latency Slower to converge Fast: run in parallel and waits for slowest branch
Reproducibility and Audit Harder: runs can differ, so you need a logged plan ledger Easy: the same branches run in the same way every time.
Resolution of the tasks Open ended with no known steps upfront Known: the same analyses run every time
Who decides what to run next Decided by AI agents and hence paths can differ Built in predictability
Dependencies between analyses Agents can interact with each if there is a dependency Suitable for independent analyses
Failure handling Stall limits and a human fallback Timeouts and system rules with assignment routed to human reviewer
7 Likes

@kaspk Nice article.

1 Like

Great article and guidance @kaspk. The collaborator/initiator agent could also kick off a rules-driven automation where an agent may not be needed. We’re seeing this become more common as organizations begin to operationalize agentic architectures and move into production. They are recognizing that the value is not there to make an LLM call in some cases and good old automation does the trick. For less and with a better, more consistent outcome.

1 Like

Completely agree!

Hi @kaspk , Great article. How does this work in case of an agent need to spin off multiple agents dynamically depending on the context or processing. Example, Supervisor agent has decided it needs to do 5 specialized tasks and spinned off 5 different agents dynamcially which can execute parallelly and once the 5 different agent execution is completed and share the results with main supervisor agent, supervisor agent does the final synthesis. How can we approach that in Pega.

Hi Sridhar, that is a very good question. There are multiple ways to achieve this, however, I will start with ‘Split-for-Each’ shape. Here, based on business rules/technical requirements you could split the flow in multiple sub-processes and each will call an agent instance. This agent will be same though, only there are multiple instance of those agents (unless your requirement is to call different agents at the same time?) . We could discuss how the design will look like for the technical process if you would like.

Hi @kaspk , Thanks for your response. My question is specifically in general if agent needs to fan out multiple agents parallelly depending on the need dynamically how we would be able to achieve that. If the requirement is clear, we can do as you suggested. But agent should dynamically decide how many sub agents or fan out agents it needs to split out how can we acheive that ?

Sridhar - we could use something like a decision API to make that decision and return us the structured response back. Or we could have an LLM call before that to decided the number agents to spin off. Also, this use case is more for automation agents and not the conversational agents.

Thanks @kaspk

Another option to consider is parallel process to spinoff multiple agents based on the necessity and it can be controlled dynamically based on the when conditions (to skip or execute the process). based on the requirements.

1 Like

Great article to leverage Split join to perform concurrent process! Thanks @kaspk!

1 Like

Thank you Ramesh. I think it will be worth exploring this with the conversation agents. The idea in my article revolves around the autmation agents.

1 Like

That’s a great option as well. Thank you!

2 Likes