Building Multi-Step Workflows Using LLMs in Software

𝗧𝗼𝗽 𝟵 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗟𝗟𝗠 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀 𝗬𝗼𝘂 𝗦𝗵𝗼𝘂𝗹𝗱 𝗞𝗻𝗼𝘄 Most people think AI = prompt → response. But real AI systems are built using workflows, not just single prompts. These workflows define how LLMs: • break problems • reason step-by-step • use tools • collaborate • improve outputs Understanding these is key to building real AI agents. Here is a simple breakdown. 1. Prompt Chaining Break a task into multiple steps where each LLM call builds on the previous one. Used for: • chatbots • multi-step reasoning • structured workflows 2. Parallelization Run multiple LLM calls at the same time and combine results. Used for: • faster processing • evaluations • handling multiple inputs 3. Orchestrator–Worker A central LLM splits tasks and assigns them to smaller worker models. Used for: • agentic RAG • coding agents • complex task delegation 4. Evaluator–Optimizer One model generates output, another evaluates and improves it in a loop. Used for: • data validation • improving response quality • feedback-based systems 5. Router Classifies input and sends it to the right workflow or model. Used for: • customer support systems • multi-agent setups • intelligent routing 6. Autonomous Workflow The agent interacts with tools and environment, learns from feedback, and continues execution. Used for: • autonomous agents • real-world task execution 7. Reflexion The model reviews its own output and improves it iteratively. Used for: • complex reasoning • debugging tasks • self-correcting systems 8. ReWOO Separates planning and execution. One part plans tasks, others execute them. Used for: • deep research • multi-step problem solving 9. Plan and Execute The agent creates a plan, executes steps, and updates based on results. Used for: • business workflows • automation pipelines 💡 Simple mental model • Chaining → step-by-step thinking • Parallel → faster execution • Orchestrator → task distribution • Evaluator → quality improvement • Router → smart decision-making • Autonomous → self-running systems 𝗪𝗵𝘆 𝘁𝗵𝗶𝘀 𝗺𝗮𝘁𝘁𝗲𝗿𝘀 Moving from: single prompts → structured workflows is what turns: LLMs → real AI systems Most people are still at the prompt level. The real power comes from designing workflows. Which workflow are you using the most right now? Image credits: Rakesh Gohel #AI #AIAgents #LLM #AgenticAI #GenAI #AIEngineering #Automation

If you are building AI agents or learning about them, then you should keep these best practices in mind 👇 Building agentic systems isn’t just about chaining prompts anymore, it’s about designing robust, interpretable, and production-grade systems that interact with tools, humans, and other agents in complex environments. Here are 10 essential design principles you need to know: ➡️ Modular Architectures Separate planning, reasoning, perception, and actuation. This makes your agents more interpretable and easier to debug. Think planner-executor separation in LangGraph or CogAgent-style designs. ➡️ Tool-Use APIs via MCP or Open Function Calling Adopt the Model Context Protocol (MCP) or OpenAI’s Function Calling to interface safely with external tools. These standard interfaces provide strong typing, parameter validation, and consistent execution behavior. ➡️ Long-Term & Working Memory Memory is non-optional for non-trivial agents. Use hybrid memory stacks, vector search tools like MemGPT or Marqo for retrieval, combined with structured memory systems like LlamaIndex agents for factual consistency. ➡️ Reflection & Self-Critique Loops Implement agent self-evaluation using ReAct, Reflexion, or emerging techniques like Voyager-style curriculum refinement. Reflection improves reasoning and helps correct hallucinated chains of thought. ➡️ Planning with Hierarchies Use hierarchical planning: a high-level planner for task decomposition and a low-level executor to interact with tools. This improves reusability and modularity, especially in multi-step or multi-modal workflows. ➡️ Multi-Agent Collaboration Use protocols like AutoGen, A2A, or ChatDev to support agent-to-agent negotiation, subtask allocation, and cooperative planning. This is foundational for open-ended workflows and enterprise-scale orchestration. ➡️ Simulation + Eval Harnesses Always test in simulation. Use benchmarks like ToolBench, SWE-agent, or AgentBoard to validate agent performance before production. This minimizes surprises and surfaces regressions early. ➡️ Safety & Alignment Layers Don’t ship agents without guardrails. Use tools like Llama Guard v4, Prompt Shield, and role-based access controls. Add structured rate-limiting to prevent overuse or sensitive tool invocation. ➡️ Cost-Aware Agent Execution Implement token budgeting, step count tracking, and execution metrics. Especially in multi-agent settings, costs can grow exponentially if unbounded. ➡️ Human-in-the-Loop Orchestration Always have an escalation path. Add override triggers, fallback LLMs, or route to human-in-the-loop for edge cases and critical decision points. This protects quality and trust. PS: If you are interested to learn more about AI Agents and MCP, join the hands-on workshop, I am hosting on 31st May: https://lnkd.in/dWyiN89z If you found this insightful, share this with your network ♻️ Follow me (Aishwarya Srinivasan) for more AI insights and educational content.

𝗧𝗵𝗲 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝗡𝗼𝗯𝗼𝗱𝘆 𝗧𝗮𝗹𝗸𝘀 𝗔𝗯𝗼𝘂𝘁: 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗡𝗢𝗧 𝗨𝘀𝗲 𝗮𝗻 𝗔𝗜 𝗔𝗴𝗲𝗻𝘁 Everyone is building agents. Most of them shouldn't be agents. This pattern keeps showing up across the industry — teams ship an autonomous AI agent for a task that should have been a three-step workflow with an LLM call in the middle. Then they spend months debugging non-deterministic failures, token cost overruns, and hallucination cascades that a simple orchestration layer would have prevented entirely. Here's the uncomfortable truth most AI content won't tell you: → About 60% of enterprise AI tasks need a simple API call. Deterministic input, deterministic output. No reasoning required. Invoice field extraction, data format conversion, log parsing — if you're wrapping these in an agent framework, you're over-engineering. → About 30% need a workflow with an LLM layer. Multi-step, but the sequence is known in advance. Email triage and response drafting. Document summarization pipelines. RAG-based Q&A. These need language understanding, but the path is predictable. A workflow engine with an LLM at specific nodes handles this cleanly. → Only about 10% genuinely need an autonomous agent. Tasks where the goal is ambiguous, the tool selection happens at runtime, and the model must plan, adapt, and self-correct based on intermediate results. Multi-source research synthesis. Codebase refactoring with test generation. Open-ended incident root cause analysis. The problem is that "agent" sounds impressive in architecture conversations. "Workflow with an LLM call" does not. So teams default to agents for everything, and then wonder why production reliability drops from 99.9% to 95%. 𝗛𝗲𝗿𝗲'𝘀 𝗮 𝗱𝗶𝗮𝗴𝗻𝗼𝘀𝘁𝗶𝗰 𝗳𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 𝘁𝗵𝗮𝘁 𝗵𝗲𝗹𝗽𝘀: → Does the first action always follow the same sequence? You built a workflow, not an agent. → Does it call the same tool every time? That's an API wrapper with extra steps. → Can a user define the exact steps in advance? Workflow. → Does the task require adapting to unexpected intermediate results? Now you might actually need an agent. → Does the model need to decide which tools to use at runtime? Agent territory. 𝗧𝗵𝗲 𝗰𝗼𝘀𝘁 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗶𝗺𝗽𝗮𝗰𝘁 𝗶𝘀 𝗿𝗲𝗮𝗹: → API calls — low latency, minimal token cost, simple debugging, 99.9% reliability → Workflow + LLM — moderate latency, moderate cost, manageable debugging, 99.5% reliability → Autonomous agents — variable latency, high token cost, painful debugging, 95-99% reliability depending on guardrails When every task is an agent, your token bill becomes unpredictable, your error traces become unreadable, and your on-call engineers start updating their resumes. What's the most over-engineered AI agent you've seen that should have been a simple workflow?

Building LLM Agent Architectures on AWS - The Future of Scalable AI Workflows What if you could design AI agents that not only think but also collaborate, route tasks, and refine results automatically? That’s exactly what AWS’s LLM Agent Architecture enables. By combining Amazon Bedrock, AWS Lambda, and external APIs, developers can build intelligent, distributed agent systems that mirror human-like reasoning and decision-making. These are not just chatbots - they’re autonomous, orchestrated systems that handle workflows across industries, from customer service to logistics. Here’s a breakdown of the core patterns powering modern LLM agents : Breakdown: Key Patterns for AI Workflows on AWS 1. Prompt Chaining / Saga Pattern Each step’s output becomes the next input — enabling multi-step reasoning and transactional workflows like order handling, payments, and shipping. Think of it as a conversational assembly line. 2. Routing / Dynamic Dispatch Pattern Uses an intent router to direct queries to the right tool, model, or API. Just like a call center routing customers to the right department — but automated. 3. Parallelization / Scatter-Gather Pattern Agents perform tasks in parallel Lambda functions, then aggregate responses for efficiency and faster decisions. Multiple agents think together — one answer, many minds. 4. Saga / Orchestration Pattern Central orchestrator agents manage multiple collaborators, synchronizing tasks across APIs, data sources, and LLMs. Perfect for managing complex, multi-agent projects like report generation or dynamic workflows. 5. Evaluator / Reflect-Refine Loop Pattern Introduces a feedback mechanism where one agent evaluates another’s output for accuracy and consistency. Essential for building trustworthy, self-improving AI systems. AWS enables modular, event-driven, and autonomous AI architectures, where each pattern represents a step toward self-reliant, production-grade intelligence. From prompt chaining to reflective feedback loops, these blueprints are reshaping how enterprises deploy scalable LLM agents. #AIAgents

I started by asking AI to do everything. Six months later, 65% of my agent’s workflow nodes run as non-AI code. The first version was fully agentic : every task went to an LLM. LLMs would confidently progress through tasks, though not always accurately. So I added tools to constrain what the LLM could call. Limited its ability to deviate. I added a Discovery tool to help the AI find those tools. Better, but not enough. Then I found Stripe’s minion architecture. Their insight : deterministic code handles the predictable ; LLMs tackle the ambiguous. I implemented blueprints, workflow charts written in code. Each blueprint specifies nodes, transitions between them, trigger conditions for matching tasks, & explicit error handling. This differs from skills or prompts. A skill tells the LLM what to do. A blueprint tells the system when to involve the LLM at all. Each blueprint is a directed graph of nodes. Nodes come in two types : deterministic (code) & agentic (LLM). Transitions between nodes can branch based on conditions. Deal pipeline updates, chat messages, & email routing account for 29% of workflows, all without a single LLM call. Company research, newsletter processing, & person research need the LLM for extraction & synthesis only. Another 36%. The workflow runs 67-91% as code. The LLM sees only what it needs : a chunk of text to summarize, a list to categorize, processed in one to three turns with constrained tools. Blog posts, document analysis, bug fixes are genuinely hybrid. 21% of workflows. Multiple LLM calls iterate toward quality. Only 14% remain fully agentic. Data transforms & error investigations. These tend to be coding tasks rather than evaluating a decision point in a workflow. The LLM needs freedom to explore. AI started doing everything. Now it handles routing, exceptions, research, planning, & coding. The rest runs without it. Is AI doing less? Yes. Is the system doing more? Also yes. The blueprints, the tools, the skills might be temporary scaffolding. With each new model release, capabilities expand. Tasks that required deterministic code six months ago might not tomorrow.

I replaced 307 lines of agent code with just 4 lines. Graph-based thinking changed everything for my LLM agents. Curious how a 100-line framework can transform your AI workflows? Read on. I've spent years building my own agent framework and teaching graph theory, but discovering PocketFlow made me rethink my approach to LLM-powered programs. Its graph-based abstraction was a game-changer for clarity and modularity. My old AgentBot implementation had a 307-line __call__ method. With PocketFlow, I rebuilt it in about 100 lines, with the core agent graph constructed in just 4 lines. PocketFlow structures LLM programs as graphs, not loops. Each Node is a unit of execution, and Flows connect them, making the logic explicit and visualizable. This shift made my code more maintainable and easier to reason about. In this blogp ost, I share concrete examples: topic extraction, agentic date retrieval, and shell command execution—all orchestrated as graphs. The new approach let me visualize agent architectures and made adding new tools trivial. The biggest lesson? Thinking in graphs, not loops, transforms how you build LLM applications. It brings clarity, modularity, and makes your execution flow explicit. If you're curious about building smarter, more maintainable LLM agents, check out my deep dive and let me know your thoughts! How are you structuring your LLM-powered workflows—loops, graphs, or something else? What challenges have you faced? #ai #llm #agentframeworks #graphtheory #machinelearning

Just wrapped up session 4 of the Python + Agents series: Building your first AI-driven workflows! 🔀 🤖 Here's what we covered: 🔧 Workflow Fundamentals — In Microsoft Agent Framework, workflows are graphs made of Executors (nodes) connected by Edges. Executors can be Agents or custom Python classes, so not every step needs an LLM. 🖥️ DevUI — A built-in tool that lets you visualize your workflow graph, run it interactively, and inspect each node's output as it completes — invaluable for debugging and iteration. 🔀 Conditional Branching — We explored routing workflows based on agent output, first with simple string checks (fragile!), then with structured outputs using Pydantic models and Literal fields for reliable, deterministic routing. Switch-case edge groups give you clean multi-way branching with a default fallback. 📦 State Management — Using set_state/get_state keeps workflows clean by avoiding the "pass-through" problem where every node carries data it doesn't need. We also discussed a critical pitfall: shared workflow instances and agent session history can leak between parallel runs. The fix? Factory functions that create fresh workflows per request. 💡 Key takeaway: Add agents where they genuinely add value — at decision points, for content generation, or for tasks that previously required human judgment. Every LLM call adds non-determinism, latency, and cost. 📺 Watch the recording: https://lnkd.in/gDN99hqP 💻 Try the code: https://lnkd.in/gA7vEAtY 📑 Slides: https://lnkd.in/gpxV93VW This is part of a 6-session series. Register @ https://lnkd.in/g9Na8iej for upcoming sessions on advanced multi-agent orchestration and human-in-the-loop workflows. #Python #AI #Agents #MicrosoftAgentFramework #LLM #Workflows #AIEngineering

Most builders stop at “call the model, get the output”.  The real lever lives in the architecture. ☑ LLM Augmentation   The model reaches out for retrieval from a vector store, calls a calculator or an API, and keeps short term context.   It builds its answer on fresh data. ☑ Prompt Chaining Workflow   One model writes a draft, another checks it, a third refines it.   Each step passes only when it meets a pass condition.   Great for reasoning, summarizing, translating. ☑ LLM Routing Workflow   The incoming request is inspected, then sent to the model or prompt that fits best.   Classification goes one way, Q &A another, summarization a third. ☑ Parallel Aggregator Workflow   Run several models or tasks at the same time.   Collect all outputs and pick the best.   Useful for ensemble opinions. ☑ Parallel Synthesizer Workflow   A control layer coordinates many agents.   It conducts the conversation and merges the replies into a single answer. ☑ Evaluator‑Optimizer Workflow   One model produces, a second model scores and gives feedback.   The loop repeats until the score crosses a threshold.   This is the most underrated pattern. If you’re an AI engineer, design for workflows, not single shots.   Build systems that self‑correct and scale. I’m Shrey Shah & I share daily guides on AI.   If this helped, hit the ♻️ reshare button to help someone else build smarter.

If AI Agents are complicated, then you can start with LLM workflows Here are a few of them you can try with code samples... Most theoretical AI Agent concepts are either too difficult to implement or something you don't exactly need right now. So, I collected 6+ Agentic workflows that are easier to build and solve a particular problem 📌 Prompt Chaining - Prompt chaining decomposes a task into a sequence of steps, where each LLM call processes the output of the previous one. 📌 Parallelization - Parallelization in LLMs involves sectioning tasks or running them multiple times simultaneously for aggregated outputs. 📌 Orchestrator-Worker - A central LLM dynamically breaks down tasks, delegates them to worker LLMs to synthesizes results. 📌 Evaluator-Optimizer - In this workflow, one LLM call generates a response while another provides evaluation and feedback in a loop. 📌 Routing - It classifies an input and directs it to a specialized followup task. This workflow allows for the separation of concerns. 📌 Autonomous Workflow - Autonomous workflow or Agents are typically implemented as an LLM performing actions based on environment/tools feedback in a loop. Note: For Prompt Chaining, Parallelization, Orchestrator-Worker, Evaluator-Optimizer, Routing, and Autonomous Workflow, you can find their code samples here: https://lnkd.in/gscuZ978 📌 Reflexion (Improved Reflection) - This architecture learns via feedback and self-reflection, reviewing task responses to improve the final response quality. - Use case: Full-Stacking App building agent (Eg; AI Agents like Lovable or Bolt new) 🔗 Langgraph Implementation: https://lnkd.in/g6zTCT86 📌 Rewoo (Reasoning Without Observation) - Agent enhances ReACT with planning and substitution, reducing tokens and simplifying fine-tuning. 🔗 Langgraph Implementation: https://lnkd.in/gy3wHusD 📌 Plan and Execute - An Architecture to create a multi-step plan, execute sequentially, review and adjust after each task. 🔗 Langgraph Implementation: https://lnkd.in/gy3wHusD If you want to understand AI agent concepts deeper, my free newsletter breaks down everything you need to know: https://lnkd.in/g5-QgaX4 Save 💾 ➞ React 👍 ➞ Share ♻️ & follow for everything related to AI Agents

LangGraph vs LangChain, many people get confused. I've explained each in simple below. 𝗟𝗔𝗡𝗚𝗚𝗥𝗔𝗣𝗛 (𝘀𝘁𝗲𝗽-𝗯𝘆-𝘀𝘁𝗲𝗽) LangGraph is a graph-driven framework for building dynamic, multi-agent AI workflows. 1. 𝗗𝗲𝗳𝗶𝗻𝗲 𝗮𝗽𝗽 𝗼𝗯𝗷𝗲𝗰𝘁𝗶𝘃𝗲 – Clearly state what your app should achieve. 2. 𝗕𝘂𝗶𝗹𝗱 𝗴𝗿𝗮𝗽𝗵-𝗯𝗮𝘀𝗲𝗱 𝗻𝗼𝗱𝗲𝘀 – Divide the workflow into nodes, each handling a specific function. 3. 𝗜𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗲 𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻 𝗽𝗮𝗿𝘁𝘀 – Use LangChain components (tools, prompts, retrievers) inside these nodes. 4. 𝗔𝘀𝘀𝗶𝗴𝗻 𝗻𝗼𝗱𝗲 𝘀𝘁𝗮𝘁𝗲𝘀 – Give each node a status like 𝘢𝘤𝘵𝘪𝘷𝘦, 𝘸𝘢𝘪𝘵𝘪𝘯𝘨, or 𝘤𝘰𝘮𝘱𝘭𝘦𝘵𝘦 to track progress. 5. 𝗖𝗼𝗻𝗻𝗲𝗰𝘁 𝘀𝘁𝗮𝘁𝗲 𝘁𝗿𝗮𝗻𝘀𝗶𝘁𝗶𝗼𝗻𝘀 – Define how one node leads to another based on outcomes or triggers. 6. 𝗗𝗲𝗽𝗹𝗼𝘆 𝗮𝗻𝗱 𝗺𝗼𝗻𝗶𝘁𝗼𝗿 – Launch the app and keep track of performance, uptime, and user behavior. 7. 𝗧𝗿𝗼𝘂𝗯𝗹𝗲𝘀𝗵𝗼𝗼𝘁 𝗲𝗱𝗴𝗲 𝗰𝗮𝘀𝗲𝘀 – Identify rare or confusing user inputs and handle them gracefully. 8. 𝗧𝗲𝘀𝘁 𝗰𝗼𝗺𝗽𝗹𝗲𝘁𝗲 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄 – Run the entire graph end-to-end to ensure smooth communication between nodes. 9. 𝗘𝗻𝗮𝗯𝗹𝗲 𝗽𝗮𝗿𝗮𝗹𝗹𝗲𝗹 𝘁𝗮𝘀𝗸 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 – Allow multiple nodes to run simultaneously for faster results. 10. 𝗔𝗱𝗱 𝗺𝗲𝗺𝗼𝗿𝘆 𝗵𝗮𝗻𝗱𝗹𝗲𝗿 – Integrate memory so the app remembers previous interactions or states. ___________________________________ 𝗟𝗔𝗡𝗚𝗖𝗛𝗔𝗜𝗡 (𝘀𝘁𝗲𝗽-𝗯𝘆-𝘀𝘁𝗲𝗽) LangChain is a developer-focused framework for creating modular, tool-powered LLM applications. 1. 𝗣𝗶𝗰𝗸 𝘆𝗼𝘂𝗿 𝗟𝗟𝗠 𝗽𝗿𝗼𝘃𝗶𝗱𝗲𝗿 – Choose the base model (like OpenAI, Anthropic, or Gemini). 2. 𝗦𝗲𝘁 𝘂𝗽 𝗽𝗿𝗼𝗺𝗽𝘁 𝘁𝗲𝗺𝗽𝗹𝗮𝘁𝗲𝘀 – Design reusable prompt formats for consistent LLM responses. 3. 𝗕𝘂𝗶𝗹𝗱 𝗺𝗼𝗱𝘂𝗹𝗮𝗿 𝗰𝗵𝗮𝗶𝗻𝘀 – Connect multiple prompts and tools to form a logical pipeline. 4. 𝗔𝗱𝗱 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝘁𝗼𝗼𝗹𝘀 – Attach external tools like search APIs or calculators. 5. 𝗟𝗶𝗻𝗸 𝗲𝘅𝘁𝗲𝗿𝗻𝗮𝗹 𝗱𝗮𝘁𝗮 𝘀𝗼𝘂𝗿𝗰𝗲𝘀 – Connect databases, PDFs, or APIs to provide context-rich information. 6. 𝗠𝗼𝗻𝗶𝘁𝗼𝗿 𝗮𝗻𝗱 𝘂𝗽𝗱𝗮𝘁𝗲 – Regularly check performance and make updates to prompts or logic. 7. 𝗗𝗲𝗽𝗹𝗼𝘆 𝗮𝘀 𝗮𝗽𝗽 – Turn the workflow into a production-ready application. 8. 𝗗𝗲𝗯𝘂𝗴 𝗮𝗻𝗱 𝗿𝗲𝗳𝗶𝗻𝗲 𝗹𝗼𝗴𝗶𝗰 – Fix errors, optimize chains, and refine responses through testing. 9. 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗲 𝗽𝗿𝗼𝗺𝗽𝘁 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 – Measure how accurately prompts generate desired outputs. 10. 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 𝘀𝘆𝘀𝘁𝗲𝗺 – Add short-term or long-term memory for contextual continuity. In short: • 𝗟𝗮𝗻𝗴𝗚𝗿𝗮𝗽𝗵 builds 𝗱𝘆𝗻𝗮𝗺𝗶𝗰, 𝗺𝘂𝗹𝘁𝗶-𝗮𝗴𝗲𝗻𝘁 𝗔𝗜 𝗳𝗹𝗼𝘄𝘀. • 𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻 builds 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱, 𝘁𝗼𝗼𝗹-𝗯𝗮𝘀𝗲𝗱 𝗟𝗟𝗠 𝗮𝗽𝗽𝘀. ✅ Repost for others in your network who can benefit from this.