Part 5 of 7 in the Logic Apps Agent Loop series
Part 4 covered the three tooling layers available to an Azure Logic Apps agent. A single agent with well-defined tools handles a wide range of integration scenarios, but some workloads are too complex for one agent to handle well. Azure Logic Apps multi-agent patterns let you compose multiple agent loops into a coordinated system, where each agent has a single focused responsibility and the output of one feeds directly into the next. This post covers the four patterns Microsoft has defined and includes a working demo that builds a two-agent sequential loop.
This post covers the four patterns Microsoft has defined for multi-agent composition in Azure Logic Apps: prompt chaining, routing, handoff, and orchestrator-workers and includes a demo that builds a two-agent sequential loop: a triage agent that classifies a customer request and hands off to a specialist agent.
Why Azure Logic Apps multi-agent patterns matter
A single agent loop works well when the task is bounded and the instructions can cover every case. The problem comes when a task has multiple distinct phases that require different expertise, different tools, or different models. Packing all of that into one agent’s instructions creates a sprawling, hard-to-maintain prompt. The model has to context-switch between roles in a single loop, which degrades quality and makes the run history harder to interpret.
Multi-agent patterns solve this by giving each agent a single, clear responsibility. The agents are composed at the workflow level: one agent’s output becomes another agent’s input, and each agent can have its own model, its own tools, and its own focused instructions.
The four Azure Logic Apps multi-agent patterns explained
Microsoft’s documentation defines four patterns for multi-agent composition in Logic Apps. They are ordered by complexity.
Prompt chaining
The simplest pattern. A sequence of agent loops runs one after another, where the output of each loop becomes the input to the next. Each agent has a single focused task: extract, then format, then sort, then summarise. The chain is linear and predictable.
Use prompt chaining when the workload can be decomposed into sequential steps with clear handover points and when the output of each step is well-defined. A business report processing chain, raw data in, executive summary out, is the canonical example from the Microsoft documentation.
Routing
A classification agent examines the incoming request and routes it to one of several specialist agent loops based on what it finds. The routing agent does not do the work itself it decides which agent should do the work and passes control there.
Use routing when incoming requests fall into distinct categories that need different handling: a customer service triage agent that routes billing queries to a billing agent loop, technical questions to a technical support agent loop, and general inquiries to a general response agent loop. The routing pattern prevents optimization conflicts, allowing a billing specialist agent to be tuned for billing tasks without being distracted by technical support scenarios.
Handoff
Similar to routing but more dynamic. Instead of a central classifier making an upfront routing decision, each agent loop decides during its own execution whether it needs to hand off to another agent. The handoff preserves conversation context and state across the transition the receiving agent knows the full history of what the previous agent did and said.
Use handoff when the trigger for transferring control depends on what emerges during the conversation: a general support agent that escalates to a technical specialist when it detects a complex issue, or a research agent that hands off to a writer agent once it has gathered enough material. The handoff pattern mimics human escalation patterns: a front-line agent handles what it can and passes on what it cannot.
Orchestrator-workers
The most sophisticated pattern. A central orchestrator agent dynamically decomposes a task into subtasks and delegates each subtask to a worker agent loop. The worker agents operate as tools that the orchestrator can invoke, exactly the tool provider pattern from Part 4, applied to agents rather than connectors.
Use orchestrator-workers when you cannot predict the required subtasks in advance. A coding agent that needs to make changes to an unpredictable number of files, a research agent that gathers information from multiple dynamic sources, or a content pipeline with a writer, reviewer, and publisher working together, these are all orchestrator-worker scenarios. The orchestrator dynamically determines what needs to be done; the workers execute it.
Demo: Building a sequential agent loop — Extract and Summarise
This demo builds a two-agent prompt chaining workflow in a new sequential-agents workflow inside la-agent-loop. The scenario is a business report processing chain: Agent 1 extracts key facts and metrics from a raw text input, Agent 2 takes those facts and writes a concise executive summary. The output of Agent 1 feeds directly into Agent 2 — this is the prompt chaining pattern in its simplest form.
Prerequisites
- The
la-agent-loopStandard logic app from previous posts - An Azure OpenAI / Foundry Models connection already configured
Step 1: Create the workflow
In la-agent-loop, click Create and name the workflow sequential-agents. Select Autonomous Agents as the workflow type. Logic Apps creates the workflow with an HTTP trigger and an empty Agent action.
Step 2: Configure the HTTP trigger
Click the When an HTTP request is received trigger and paste this request body schema:
{
"type": "object",
"properties": {
"report": {
"type": "string"
}
},
"required": ["report"]
}
Step 3: Configure the Extract Agent
Click the first Agent action and rename it Extract Agent. Configure it:
- AI model: your GPT-4o / Foundry Models connection
- Instructions:
You are a data extraction specialist. Extract all numerical values, metrics, and key facts from the provided text. Return them as a clean bulleted list. Do not summarise or interpret — only extract. - User instructions item – 1: select
reportfrom the HTTP trigger dynamic content
Step 4: Add a Compose action
This is a critical step. The Extract Agent output is a JSON object containing a messages array — not a plain string. The Summarize Agent cannot process it directly. A Compose action between the two agents extracts the plain text content.
Click + below the Extract Agent container and add Add an action → Simple Operations → Compose. Set the Inputs expression to:
outputs('Extract_Agent')?['body']?['messages'][0]['content']
This extracts the bulleted list text from the Extract Agent’s output object and passes it as a clean string to the next agent.
Step 5: Add the Summarize Agent
Click + below the Compose action and select Add an agent. Rename it Summarize Agent. Configure it:
- AI model: your GPT-4o / Foundry Models connection
- Instructions:
You are an executive communications specialist. Take the provided list of facts and metrics and write a concise three-sentence executive summary suitable for a board report. Be professional and direct. - User instructions item – 1: select the Outputs of the Compose action from the dynamic content picker
Step 6: Add a Response action
Click + below the Summarize Agent container and add a Response action:
- Status Code:
200 - Content-Type header:
application/json - Body: set the expression to
outputs('Summarize_Agent')?['body']?['messages'][0]['content']
Step 7: Save and test
Save the workflow and POST this to the trigger URL:
{ "report": "Q3 revenue was €4.2M, up 18% year on year. Customer acquisition cost dropped to €142, down from €198. Net promoter score reached 67. Headcount grew from 43 to 51. Churn rate fell to 2.3%." }
The workflow runs in approximately 16 seconds and returns a clean executive summary:
In Q3, revenue reached €4.2M, reflecting an 18% year-on-year increase, supported by a significant reduction in customer acquisition cost from €198 to €142. The company saw operational growth with headcount rising from 43 to 51, while maintaining strong customer satisfaction, evidenced by a Net Promoter Score of 67 and a low churn rate of 2.3%. These metrics highlight sustained growth and improved efficiency across key areas.
The run history shows two distinct agent iterations, Extract Agent and Summarize Agent, each with their own Think → Observe cycle, confirming the prompt chaining pattern is working end to end.
Practitioner note: The Compose action between the two agents is not optional. Logic Apps Agent actions return a structured JSON object not a plain string, so the second agent cannot consume the first agent’s output directly from dynamic content. The Compose expression
outputs('Extract_Agent')?['body']?['messages'][0]['content']bridges this gap. This is not documented clearly by Microsoft at the time of writing and is the most common point of failure when building sequential agent loops.
Choosing the right pattern
| Pattern | Complexity | Use when |
|---|---|---|
| Prompt chaining | Low | Sequential steps with clear handover points |
| Routing | Low–medium | Distinct input categories needing different handling |
| Handoff | Medium | Dynamic escalation based on conversation content |
| Orchestrator-workers | High | Unpredictable subtasks requiring dynamic decomposition |
The patterns are not mutually exclusive. A production customer service system might use routing to direct initial requests, handoff for mid-conversation escalations, and prompt chaining within each specialist agent to process the request through multiple steps.
What comes next
Part 6 covers securing agentic workflows, the expanded caller surface introduced by multi-agent and conversational patterns, Easy Auth setup for production, and Managed Identity for backend connections.