Building Agentic Workflows

Go beyond the AI agent hype with a deep dive into the practical architecture of agentic systems. Presented at apidays Paris 2025, Gbadebo Bello (Developer Advocate at Postman) breaks down the orchestration patterns required to build reliable, production-grade AI agents.

Key Technical Insights:
• Orchestration Patterns: Strategies for structuring single and multi-agent systems.
• Reasoning Loops: Deep dive into ReAct frameworks and intelligent tool calling.
• Decision Frameworks: How to choose architectures based on complexity and specialization.
• From Prototype to Production: Moving from "toy" agents to context-aware, human-in-the-loop systems.

A definitive blueprint for developers building the next generation of autonomous workflows.

------------------------------------

Conference Details:
Conference: apidays Paris 2025, part of FOST (Future of Software Technologies)
Theme: The APIs meet AI Conference: Innovation, Security, Sovereignty, Sustainability
Date: 9 - 11 December 2025 • CNIT Forest, Paris

Transcript

1. © All rights reserved by Postman Inc Gbadebo Bello Developer Advocate Building Agentic Workflows: Patterns for Orchestrating Intelligent Systems
2. We’re experiencing a technological renaissance
3. AI Agents are not black boxes
4. What we’ll go over: ✦ The basics: We’ll review core agentic components and how they tie to each other ✦ Agentic Perception and Memory ✦ Agentic Orchestration Patterns(simple and advanced) ✦ Design a simple Agentic workflow using these patterns ✦ Decision frameworks for choosing between different orchestration patterns ✦ Recommendations
5. The Basics
6. Basic LLM Request
7. Perception - Reasoning - Action
8. Perception - Reasoning - Action
9. To perceive the surrounding and be context aware, an agent needs to keep track of the following: ✦ Task context: the goal, instructions, constraints, and what the user is actually asking for. ✦ Interaction context: the conversation history, agent’s own previous steps, tool calls, outputs, and errors. ✦ User context: preferences, tone, past behavior, and personalized settings that shape how the agent should respond. ✦ Environment & knowledge context: real-time external data, system state, documentation, schemas, and any knowledge beyond the model’s training. These and more make up the Agent’s memory Agents need Perception
10. ✦ Short Term Memory: Holds context within a single session or interaction ✦ Long term memory: Memories that persists across sessions e.g ChatGPT personalization settings ✦ External Knowledge: Ability to look up information from other sources. Databases, documents, knowledge bases, or APIs. How are Agents able to remember things
11. A Complete Agentic Loop
12. Agentic Orchestration Patterns
13. ✦ Tool calling loops ✦ ReAct ✦ Plan-and-execute patterns Single-agent orchestration patterns
14. Tool Calling Loop
15. ReAct (reasoning + acting) An agent asked to “Find the most affordable flight to London” might: Think: “I need to check flight aggregators.” Act: Call a flight search API. Observe: See several options. Think: “Now I’ll filter by price and airline.” Act: Return the best result.
16. Plan-and-execute - Plans can be a todo list in markdown - Agent review and updates the status of this plan across each step(pending, in_progress, or completed) or even add notes. - If a step fails, it doesn't just retry blindly, it updates the plan to accommodate the failure
17. Multi-Agent Orchestration Patterns
18. ✦ Manager-Worker Pattern ✦ Decentralized handoff pattern Multi-agent coordination patterns
19. Manager-Worker Pattern Manager Handles: - Task Delegation - Planning Worker Agents: - Execute specific tasks - Are focused on a single domain - Have their own respective tools
20. Decentralized handoff pattern - No Manager - Each Agent is capable of interacting with users - Agent summarizes and passes over context to the next agent - Each Agent can use different models - Agents can have shared memory
21. ✦ Plan-and-execute: Great for tasks that can be broken down into a step by step process ahead of time. Coding Agents use this a lot to clearly define steps before execution. ✦ Tool calling loops: If the task requires dynamic execution and and the LLM cannot come to a conclusion on one iteration. The agent acts, observes outcomes, and iterate on the outcomes. ✦ ReAct-style reasoning: Provides step-by-step transparency into how the agent came about certain decisions. It gives the agent an opportunity to reflect on its thought process before taking the next step. ✦ Mixed Orchestration patterns: You can combine some or all of these patterns. How to select an agent orchestration pattern
22. ✦ Manager-Worker pattern has centralized control and clear coordination. ✦ Decentralized Handoffs offer autonomy and high scalability. ✦ The Manager can be a bottleneck and a single point of failure. ✦ Decentralized flow is harder to observe and debug due to high flexibility. ✦ Manager-Worker is efficient for parallel or sequential tasks. How to select an agent orchestration pattern
23. Let’s Design an AI Agent Together Build AI Agent
25. ✦ Who will use this Agent ✦ What tasks should it handle end to end? ✦ What is out of Scope? ✦ How safe does it need to be? (guardrails, approvals)? Clarify the Agent’s Job
26. At minimum… ✦ Interface layer – where messages come from (UI, API, etc.) ✦ Orchestrator – decides what to do next ✦ Model(s) – LLMs / tools for reasoning ✦ Tools – APIs, databases, workflows ✦ Memory / context store – what it remembers ✦ Guardrails / policy – what’s allowed
27. Define Tools For each tool, define… Name + description (what it does), JSON schema for arguments, Return shape But… These tools are related but also do very specialized and unrelated things.
28. Thinking Agentically We need multiple Agents to solve this problem
29. Thinking Agentically Decentralized hand-offs OR Manager worker pattern?
30. Define Agents First, let’s define what each Agent does before we select a pattern Agent A(ReAct) Agent B(Plan and execute) Agent C Answers technical questions. Has access to knowledge base tools. Tools are available via an MCP server exposed by Postman documentation team. Can make multiple queries to different sources to get answers that it needs (Postman docs, community forum, etc) Generate tests and pm scripts. This is a coding Agent. Makes a list of coding tasks and executes each task to solve the problem. Creates Postman Resources(requests, collections, etc). Can create single resource or multiple resources. All of this provided via and MCP server.
31. Thinking Agentically In one single prompt, a user can ask the Agent to : ✦ Create resources ✦ Answer questions ✦ Write tests, etc. Hence, we need a central task manager. The manager pattern will work better for us here.
32. Choice of Model What model would work best for each Agent?
33. Model Comparisons
34. Agent A(ReAct) Agent B(Plan and execute) Agent C Manager Needs to answer technical questions. Needs a reasoning model that can think through it’s answer and scrutinize itself before answering any questions This is a coding Agent. Needs a model that is good at code generation. E.g OpenAI Codex, Claude sonnet 4 Creates Postman Resources. No reasoning model needed. Manages task list and delegation. Uses all three orchestration pattern: (plan & execute) + ReAct + (tool agent calling loop) Define Agents First, let’s define what each Agent does before we select a pattern
35. Manager Agent Architecture
36. Thinking Agentically How how do I write contract tests in Postman? Can you generate a contract test for this request? - Manager: Thinks through the question - Manager: Creates a list of tasks to execute - Explain how to write contract tests to user - Generate a contract test for user - Manager: decides what Agent to pass task 1 to. - Manager: gets necessary context and passes down the task to the Agent A to explain the technical concept Or first asks users clarifying questions, then passes contect down - Agent A: reasons through context, and uses resources user has access to to explain how to write a contract test - Agent A: Passes context back to Manager - Manager: Checks if task list needs to be adjusted - Manager: Passes context down to Agent B to write some code - Agent B: reasons through problem, analyzes context, and creates a task list of how to approach writing the code - Agent B: executes each task over a loop, generates the test, and returns context back to Manager - Manager: analyzes received context, and passes necessary context down to Agent C to update request - …..and so on until manager arrives at a final answer What are the different variable scopes available? - Manager: Thinks through the question - Manager: Creates a task with one single Item: defer to Agent A - Agent A: receives the context from manager. - Agent A: thinks through the questions and checks trained data - Agent A: uses MCP to get information from the knowledgebase(docs) - Agent A: passes context back to Manager - Manager: generates a final response and answers the user
37. Thinking Agentically Question: What are the different variable scopes available? - Manager: Thinks through the question - Manager: Creates a task with one single Item: defer to Agent A - Agent A: receives the context from manager. - Agent A: thinks through the questions and checks trained data - Agent A: uses MCP to get information from the knowledgebase(docs) - Agent A: passes context back to Manager - Manager: generates a final response and answers the user
38. Thinking Agentically
39. Thinking Agentically Question: How how do I write contract tests in Postman? Can you generate a contract test for this request? - Manager: Thinks through the question - Manager: Creates a list of tasks to execute - Explain how to write contract tests to user - Generate a contract test for user - Manager: decides what Agent to pass task 1 to. - Manager: gets necessary context and passes down the task to the Agent A to explain the technical concept Or first asks users clarifying questions, then passes contect down - Agent A: reasons through context, and uses resources user has access to to explain how to write a contract test - Agent A: Passes context back to Manager - Manager: Checks if task list needs to be adjusted - Manager: Passes context down to Agent B to write some code
40. Thinking Agentically - Agent B: Receives context and task information from Manager. - Agent B: reasons through problem, analyzes context, and creates a task list tasks on how to approach writing the code - Agent B: Fetches external resources it needs like the necessary schemas fi not already provided. - Agent B: executes each task over a loop, generates the contract tests, and returns context back to Manager
41. Thinking Agentically - Manager: Receives context from Agent B - Manager: Summarizes received context - Manager: Passes context plus next task to Agent C - Agent C: analyzes received context and reasons through it. - Agent C: Creates different resources over a tool loop call. - Agent C: Returns context back to the Manager - Manager: Decides if it needs any other Agent to do anything further of if there are still pending items on the task lists. If not, creates a response for the user
42. Recap ✦ The basics: We’ll review core agentic components and how they tie to each other ✦ Agentic Perception and Memory ✦ Agentic Orchestration Patterns(simple and advanced) ✦ Design a simple Agentic workflow using these patterns ✦ Decision frameworks for choosing between different orchestration patterns ✦ Recommendations
43. Highlights ✦ Agents should not be jack of all trades. Agents should be specialized and optimized to be good at specific domains. ✦ Planning should always be explicit ✦ Memory should be persistent (Save the context window when you can) ✦ Context Engineering + Prompt Engineering = the new prompt engineering
44. The future is Agentic, and AI Agents shouldn’t be a black box The Future
45. Connect with me: H linkedin.com/in/gbahdeyboh @Gbahdeyboh Gbadebo Bello Developer Advocate, Postman