Workflow vs Agents

14 Nov, 2025

Workflow vs Agents

When we automate tasks with LLMs, there are two types:

Workflow-based applications.
Agent-based applications.

First lets define the skeleton of automating tasks with LLMs.

Task (f): This is "like" a function. Where we give input and we want to get an output. If we can breakdown a task into composable steps (f1, f2, f3, ...)

then f = f1 o f2 o f3 o ...

Example 1: Airport Security Task

Task: Security check at the airport, where an officer checks your ID card and flight boarding pass to verify your identity.

INPUT: ID card, flight boarding pass, Person Live photo OUTPUT: Pass/Fail (Boolean Output1 and Output2)

                                  ┌─────────────┐
                                  │    START    │
                                  └──────┬──────┘
                                         │
                      ┌──────────────────┴──────────────────┐
                      │                                     │
                      ▼                                     ▼
              ┌──────────────┐                  ┌────────────────────┐
              │ ID VERIFIER  │                  │ FLIGHT DETAILS     │
              └──────────────┘                  │   VERIFIER         │
                      │                         └─────────┬──────────┘
         ┌────────────┼────────────┐                      │
         │            │            │                      │
         ▼            ▼            ▼                      ▼
    ┌────────┐  ┌─────────┐  ┌─────────┐          ┌─────────────┐
    │  live  │  │   id    │  │ flight  │          │   flight    │
    │  foto  │  │  image  │  │ boar.   │          │   boar.     │
    └───┬────┘  └────┬────┘  │  pass   │          │   pass      │
        │            │       └─────────┘          └──────┬──────┘
        │            ▼                                    │
        │       ╭─────────╮                              ▼
        │       │ extract │                         ╭─────────╮
        │       │   id#   │                         │ extract │
        │       ╰────┬────╯                         │ details │
        │            │ id#                          ╰────┬────╯
        │    ┌───────┴────────┐                          │
        │    │                │                          ▼
        │    ▼                ▼                   ┌──────────────┐
        │ ◇─────◇         ◇─────◇                │  - name      │
        │ │ get │         │ get │                │  - flight #  │
        │ │photo│         │name │                └──────┬───────┘
        │ │from │         │from │                       │
        │ │id db│         │id db│                       │
        │ ◇─────◇         ◇─────◇                       │
        │    │     db_photo   │                         │
        │    └────────┬───────┘                         │
        ▼             │                                 │
   ╭─────────╮        │                                 │
   │similarity│◄──────┘                                 │
   │  check  │                                          │
   ╰────┬────╯                                          │
        │                                               │
        │              ╭──────────╮                     │
        └─────────────►│ equality │◄────────────────────┘
                       │  check   │
                       ╰────┬─────╯
                            │
              ┌─────────────┴──────────────┐
              │                            │
              ▼                            ▼
       BOOLEAN OUTPUT1              BOOLEAN OUTPUT2

The above task can be automated like this:

Workflow Breakdown

The process starts at START and branches into two parallel verification paths:

ID VERIFIER Path

Inputs:

live foto: Live photo of the person
id image: Image of the ID card

Steps:

extract id#: Extract the ID number from the id image
get photo from id db: Query the ID database using the extracted id# to retrieve the stored photo (db photo)
get name from id db: Query the ID database using the extracted id# to retrieve the stored name
similarity check: Compare the live foto with the db photo from the database
BOOLEAN OUTPUT1: Result of the photo similarity check (True/False)

FLIGHT DETAILS VERIFIER Path

Inputs:

flight boar. pass: Flight boarding pass

Steps:

extract details: Extract information from the boarding pass:
- Name
- Flight number
Data display node contains the extracted details

Convergence and Final Verification

equality check: Compare the name retrieved from the ID database (from ID VERIFIER path) with the name extracted from the flight boarding pass (from FLIGHT DETAILS VERIFIER path)

BOOLEAN OUTPUT2: Result of the name equality check (True/False)

Here the steps we have are:

extract id#
get photo from id db
get name from id db
"foto" similarity check
extract details
equality check

Here we can clearly define the order of the steps and the dependencies. For optimization, we are running steps (2-4) and (3-5) in parallel. However, both parallel branches must wait for step 1 to complete first.

Key Insight: Whenever you can break down a task into a deterministic DAG (Directed Acyclic Graph) structure with clearly defined step ordering and dependencies, we call that a WORKFLOW.

💡 WORKFLOW = Deterministic task breakdown with explicit dependencies and execution order

Lets take a look at another example.

Example 2: Medical Diagnosis Agent

Task: Diagnose a patient's condition based on symptoms

INPUT: Initial symptoms, patient age, medical history
OUTPUT: Diagnosis with confidence level and treatment recommendations

Why This Requires an Agent (Not a Workflow)

Unlike the airport security example where we knew all the steps upfront, medical diagnosis cannot be predetermined because:

The diagnostic path depends on what you discover at each step
Each test result changes the probability distribution of possible diagnoses
Some findings rule out entire branches, others open new investigation paths
May need to backtrack if initial hypothesis proves wrong
Different patients with the same initial symptom require completely different tool sequences

Two Patient Scenarios

Let's see how the same initial complaint leads to completely different diagnostic paths:

Scenario A: 28-year-old with fever and dry cough

Scenario B: 55-year-old with fatigue and unexplained weight loss

                                    ┌─────────────┐
                                    │   START     │
                                    │  + symptoms │
                                    │  + age      │
                                    │  + history  │
                                    └──────┬──────┘
                                           │
                                           ▼
                              ┌────────────────────────┐
                              │  TOOL: symptom_analyzer│
                              │  Extract key symptoms  │
                              │  & severity scores     │
                              └───────────┬────────────┘
                                          │
                    ┌─────────────────────┴─────────────────────┐
                    │                                             │
        [Patient A: fever + cough]                   [Patient B: fatigue + weight loss]
                    │                                             │
                    ▼                                             ▼
        ┌───────────────────────┐                    ┌──────────────────────┐
        │ AGENT REASONING:      │                    │ AGENT REASONING:     │
        │ Acute respiratory +   │                    │ Chronic systemic +   │
        │ Recent pandemic       │                    │ Age 55+ = concern    │
        │ → Check infection     │                    │ → Check metabolic    │
        └───────────┬───────────┘                    └──────────┬───────────┘
                    │                                           │
                    ▼                                           ▼
        ┌───────────────────────┐                    ┌─────────────────────┐
        │ TOOL: vital_checker   │                    │ TOOL: vital_checker │
        │ Temp: 101.2°F         │                    │ BP: normal          │
        │ SpO2: 96%             │                    │ HR: 52 bpm (LOW)    │
        │ Resp: 22/min          │                    │ Temp: 97.1°F (LOW)  │
        └───────────┬───────────┘                    └──────────┬──────────┘
                    │                                           │
                    ▼                                           ▼
        ┌───────────────────────┐                    ┌─────────────────────┐
        │ AGENT REASONING:      │                    │ AGENT REASONING:    │
        │ Fever confirmed +     │                    │ Low HR + Low temp = │
        │ Good O2 = likely      │                    │ HYPOTHYROID pattern │
        │ upper respiratory     │                    │ Weight loss unusual │
        │ → Pandemic test first │                    │ → Thyroid labs      │
        └───────────┬───────────┘                    └──────────┬──────────┘
                    │                                           │
                    ▼                                           ▼
        ┌───────────────────────┐                    ┌─────────────────────┐
        │ TOOL: covid_test      │                    │ TOOL: lab_order     │
        │ Result: POSITIVE      │                    │ TSH, T3, T4         │
        │                       │                    │                     │
        └───────────┬───────────┘                    └──────────┬──────────┘
                    │                                           │
                    ▼                                           ▼
        ┌───────────────────────┐                    ┌─────────────────────┐
        │ AGENT REASONING:      │                    │ TOOL: lab_results   │
        │ Confirmed COVID-19    │                    │ TSH: 0.1 (very LOW) │
        │ No severe symptoms    │                    │ T4: HIGH            │
        │ → Check risk factors  │                    │ T3: HIGH            │
        └───────────┬───────────┘                    └──────────┬──────────┘
                    │                                           │
                    ▼                                           ▼
        ┌───────────────────────┐                    ┌─────────────────────┐
        │ TOOL: history_checker │                    │ AGENT REASONING:    │
        │ No chronic conditions │                    │ WAIT! High thyroid  │
        │ Vaccinated            │                    │ but WEIGHT LOSS?    │
        │                       │                    │ Should gain weight! │
        └───────────┬───────────┘                    │ → HYPERthyroid      │
                    │                                │ → Check antibodies  │
                    ▼                                └──────────┬──────────┘
        ┌───────────────────────┐                              │
        │ DIAGNOSIS:            │                              ▼
        │ COVID-19 (mild)       │                    ┌─────────────────────┐
        │                       │                    │ TOOL: antibody_test │
        │ RECOMMENDATION:       │                    │ Anti-TSH receptor   │
        │ - Home isolation      │                    │ Result: POSITIVE    │
        │ - Symptomatic care    │                    └──────────┬──────────┘
        │ - Monitor O2          │                              │
        └───────────────────────┘                              ▼
                                                     ┌─────────────────────┐
                                                     │ AGENT REASONING:    │
                                                     │ TSH-receptor Ab +   │
                                                     │ Confirms Graves'    │
                                                     │ → Check for         │
                                                     │ complications       │
                                                     └──────────┬──────────┘
                                                                │
                                                                ▼
                                                     ┌─────────────────────┐
                                                     │ TOOL: symptom_scan  │
                                                     │ Check: tremors,     │
                                                     │ heat intolerance,   │
                                                     │ eye changes         │
                                                     └──────────┬──────────┘
                                                                │
                                                                ▼
                                                     ┌─────────────────────┐
                                                     │ DIAGNOSIS:          │
                                                     │ Graves' Disease     │
                                                     │ (Hyperthyroidism)   │
                                                     │                     │
                                                     │ RECOMMENDATION:     │
                                                     │ - Endocrinology ref │
                                                     │ - Anti-thyroid meds │
                                                     │ - Beta blockers     │
                                                     └─────────────────────┘

Why An Agent Is Essential

Tool Execution Comparison

Patient A Path:

symptom_analyzer → vital_checker → covid_test → history_checker → DONE
(4 tools, linear path)

Patient B Path:

symptom_analyzer → vital_checker → lab_order → lab_results 
    → [PIVOT] → antibody_test → symptom_scan → DONE
(6 tools, with mid-course correction)

Key Decision Points (Why Predetermined DAG Fails)

After symptom_analyzer:
- Agent must choose between infectious disease tools vs. metabolic panels
- Choice depends on: age, acuity, symptom pattern
After vital_checker (Patient B):
- Low HR + Low temp suggests hypothyroid
- But agent keeps open mind (doesn't commit to diagnosis yet)
After lab_results (Patient B) - CRITICAL PIVOT:
- Results CONTRADICT initial hypothesis!
- Hypothyroid would show HIGH TSH + LOW T4
- Actually shows LOW TSH + HIGH T4 = Hyperthyroid
- Weight loss now makes sense (hypermetabolic state)
- Agent must backtrack reasoning and take new path
Dynamic tool selection:
- Patient A: Never needed thyroid tests, antibody tests, or symptom scans
- Patient B: Never needed respiratory tests
- Impossible to know upfront which tools to use

Non-Deterministic Edges

┌────────────────┐ │ START │ │ │ │ - symptoms │ │ - age │ │ - history │ └────────┬───────┘ │ ▼ ◇──────────◇ │ vitals │ │ _check │ ◇──────────◇ │ * vitals ▼ ◇──────────◇ ┌──────────────────────┐ │ covid │ ╭──────────────╮ │ CASE NOTES/ │ │ _test │ │ │ │ AGENT MEMORY │ ◇──────────◇ │ Diagnosis │- - - >│ TOOL SET │ ▲ │ Agent │ │ │ │ │ │ │ - CRUD of memory │ └ ─ ─ ─ ─ ─ ╰──────┬───────╯ │ - Summarise history │ ◇──────────◇ │ │ - Get a specific │ │ lab │ │ │ detail. │ │ _order │ │ └──────────────────────┘ ◇──────────◇ │ ▲ │ └ ─ ─ ─ ─ ─ ─ ─ ─ ─┤ ◇──────────◇ │ │ antibody │ │ │ _tst │ │ ◇──────────◇ │ ▲ │ └ ─ ─ ─ ─ ─ ─ ─ ─ ─┤ │ ◇──────────◇ │ │ ask │ │ │ _patient │◄────────────┘ ◇──────────◇

The Impossibility of Workflow Approach

A workflow would need to:

1. Check ALL possible symptoms ❌ (expensive, time-consuming)
2. Run ALL possible tests ❌ (harmful to patient, costly)
3. Have branches for every disease combination ❌ (exponential complexity)

An agent instead:

1. ✓ Reasons about probabilities
2. ✓ Selects minimal necessary tests
3. ✓ Adapts when findings contradict hypothesis
4. ✓ Uses domain knowledge to guide exploration
5. ✓ Terminates when confidence threshold reached

Key Insight: Medical diagnosis requires an intelligent agent that can dynamically plan its investigation strategy based on what it learns at each step. The DAG cannot be drawn before execution - it emerges through the agent's reasoning process.

💡 AGENT = Non-deterministic task breakdown where the execution path is determined dynamically based on findings at each step

How do we build this with DSPy?

EXAMPLE 1: Airport Security Task

import dspy

# DISCLAIMER: as of nov 2025, this doesn't work because dspy doesn't support image input/output. But just for the sake of example, let's pretend it does.
class ExtractIdNumber(dspy.Signature):
    """Extract the ID number from the ID card"""
    id_card: Image = dspy.InputField()
    id_number: str = dspy.OutputField()

class SimilarityCheck(dspy.Signature):
    """Check if the live foto is similar to the photo from the ID database"""
    live_foto: Image = dspy.InputField()
    db_photo: Image = dspy.InputField()
    is_similar: bool = dspy.OutputField()

class AirportSecurityTask(dspy.Module):
    def __init__(self):
        super().__init__()
        self.extract_id_number = dspy.ChainOfThought(ExtractIdNumber)
        self.similarity_check = dspy.ChainOfThought(SimilarityCheck)

    def forward(self, live_foto: Image, id_card: Image, flight_boarding_pass: Image) -> bool:
        id_number = self.extract_id_number.run(id_card)
        # Run face match and name match in parallel
        import concurrent.futures
        
        with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
            # Submit face match task
            face_match_future = executor.submit(
                lambda: (
                    self.get_photo_from_id_db(id_number),
                    lambda db_photo: self.similarity_check(live_foto, db_photo)
                )
            )
            
            # Submit name match task
            name_match_future = executor.submit(
                lambda: (
                    self.get_name_from_id_db(id_number),
                    self.extract_flight_details(flight_boarding_pass)
                )
            )
            
            # Get face match result
            db_photo, similarity_fn = face_match_future.result()
            is_similar = similarity_fn(db_photo)
            
            # Get name match result
            name, flight_details = name_match_future.result()
            is_name_equal = name == flight_details['name']

        return is_similar and is_name_equal

    @staticmethod
    def get_photo_from_id_db(id_number: str) -> Image:
        pass

    @staticmethod
    def get_name_from_id_db(id_number: str) -> str:
        pass

    @staticmethod
    def extract_flight_details(flight_boarding_pass: Image) -> Dict[str, str]:
        pass

EXAMPLE 2: Medical Diagnosis Agent

import dspy
from typing import Dict, List, Optional, Any
from dataclasses import dataclass

# Define the tools available to the agent

@dataclass
class PatientData:
    symptoms: List[str]
    age: int
    medical_history: List[str]

class Diagnosis:
    diagnosis: str
    confidence: int

class MedicalDiagnosisAgentSign(dspy.Signature):
    """Analyze patient symptoms and extract key symptoms with severity scores"""
    symptoms: List[str] = dspy.InputField(desc="List of patient symptoms")
    age: int = dspy.InputField(desc="Patient age")
    medical_history: List[str] = dspy.InputField(desc="Patient medical history")
    diagnosis: List[Diagnosis] = dspy.OutputField(desc="List of possible diagnoses")

def check_vitals():
    """Check patient vital signs"""
    pass

def covid_test():
    """Check if the patient has COVID-19"""
    pass

def lab_order():
    """Order laboratory tests"""
    pass

def ask_patient_questions(questions: List[str]) -> List[str]:
    """Ask the patient questions to get more information"""
    pass


class MedicalDiagnosisAgent(dspy.Module):
    """A Medical Diagnosis Agent."""

    def __init__(self, memory: Memory):
        super().__init__()

        self.memory_tools = MemoryTools(memory)
        mem_tools = [
            store_memory,
            search_memories,
            get_all_memories,
            update_memory,
            delete_memory
        ] # lets assume that these are the memory tools that we want to use.
        self.tools = [check_vitals, covid_test, lab_order, ask_patient_questions, get_current_time, *mem_tools]

        self.react = dspy.ReAct(
            signature=MedicalDiagnosisAgentSign,
            tools=self.tools,
            max_iters=6
        )

    def forward(self, symptoms: List[str], age: int, medical_history: List[str]) -> List[Diagnosis]:
        """Diagnose the patient's condition."""
        return self.react(symptoms=symptoms, age=age, medical_history=medical_history)

Why I use DSPy for building automations with LLMs?

My task breakdown into sub-tasks is focused on the composable functions' input-output, that is what defines a sub-task for me. In this library, I can exactly define the sub-tasks perfectly as per my task breakdown. Thereby making it the most intuitive way to build automations with LLMs (for me, and in my opinion for everyone else too).