Group Chat Orchestration: How to achieve this with Pega

Now when multiple agents are talking with each other and sharing notes, you may wonder why this use case should belong in Pega. And that’s the right question. But that does not mean you cannot have a predictable output at the end of the group chat, which is a staple for any regulated enterprise. If your goal is that agents talk to each other under governing policies and do not propose any action out of the ordinary, you can think of implementing this within Pega.

When is Group Chat needed?

This is needed when the decisions don’t come from a single analysis. E.g. a proposal for a site, tariff or launch, or an exception to a policy or a design review that needs several experts to challenge one another before anyone signs off. A pipeline cannot do this, because each step only sees what has come before it. Parallel branches can’t do it either, because the branches never reach each other’s work.

Definition of Group Chat Orchestration

As per Microsoft Azure article here about the agentic architecture patterns, group chat orchestration is when the agents are working together “by participating in a shared conversation thread where they collaboration through discussion.”

It’s also called roundtable, multiagent debate, or council.

This has three parts –

  1. A Chat Manager – coordinates the discussion. It picks the next speaker and keeps the debate on track, decided when the task is done.
  2. The shared thread – holds every message from every agent and human. Each agent reads it before speaking.
  3. The human observer – reads along, answers agents’ questions or takes over as chat manager.

Agents in this pattern are usually read-only. They reason and comment, but they don’t change live systems.

How this can be implemented in Pega?

Let’s take an example of an insurer who receives a disputed property claim. This claim is over its automatic settlement limit. A claim case runs a debate between three specialise agents – coverage, fraud signals and litigation exposure. The claims manager follows along and adds what the agents can’t know, such as notes from a call with policy holder.

This pattern can be assembled in Pega using the standard case building block.

Orchestration Component Pega Building block What it does?
Shared thread A page list (let’s call it ‘DiscussionThread’) on the case Stores speaker, round and message for every post
Chat manager GenAI Agent step with structured output Reads the thread and appends one message per turn
Turn routing Decision shape on the speaker field Sends the flow to the chosen agent
Human observer Assignment to the claims manager Posts messages or adds claim evidence mid-debate
Loop control Round counter and a decision shape Exits on consensus or at the round cap

The decision shape branches on a field so the routing is predictable and easy to audit.

Let’s see how this can look in the Pega flow:

  1. The flow starts with a utility to set the round counter to 0
  2. The chat manager is a GenAI step and reads ‘DiscussionThread’ and returns the next speaker and a consensus flag. (This step can also be easily converted to Decision API and that is the beauty of the open architecture)
  3. A decision shape check the consensus flag. If the consensus is reached, a utility step writes the final summary and the flow ends.
  4. A second decision shape checks the round counter. At the cap, the flow routes to a reviewer assignment with the open objections listed.
  5. Otherwise, the next speaker decision shape routes to the chosen step agent.
  6. This agent read the thread and returns one message
  7. Two utility steps append the message to DiscussionThread, increments the round counter and loops back to the chat manager.

Decision choices and risk mitigation

Concern Risk How Pega mitigates/can mitigate it?
Endless debate Agents keep talking and the case never moves Sets a round cap and decision shape that always checks it
No clear finish the manager can’t tell when the task is done Give the chat manager written consensus criteria and return a consensus flag as a structured output
Too many voices Each added agent makes the flow harder to steer Keep to three agents or fewer as Microsoft recommends
Growing context The thread grows every round, raising cost and lowering quality Summarise older rounds before passing the thread to the next agent, and set a token budget per case.
Agents acting on systems A debate step changes live data Keep debate agents read-only; put any action after the loop, behind an assignment.

Key takeaways

  1. Use group chat orchestration when a decision benefits from experts challenging each other and a human needs to follow the debate
  2. Start small with two to three agents, a low round cap and a reviewer assigbment as the fallback. Once the debate converges reliably, raise the cap or add a voice.