Stop Using Mega-Prompts: Build a Multi-Agent Hospital for Your AI Using LangGraph

Introduction

Imagine you walk into a clinic with a complex medical issue.

A Single-Agent AI system is like seeing a General Practitioner (GP). The GP tries to do everything: take your history, review your reports, analyze your X-rays, and recommend treatment. For simple issues, this works well because it is fast and efficient.

However, as complexity increases, the GP can become overwhelmed. Important details may be missed, and context switching can reduce accuracy.

A Multi-Agent AI system is more like a modern hospital. You first see an Intake Nurse, then a Radiologist, followed by a Surgeon or Specialist. Each professional focuses on a specific task and passes information through a shared medical record.

The same principle applies to AI systems.

Single-Agent systems use one Large Language Model (LLM) with a large prompt and multiple tools.
Multi-Agent systems use multiple specialized LLMs, each responsible for a specific task and coordinated through a framework such as LangGraph.

In this article, we'll compare both approaches and build an end-to-end Insurance Claims Processing System using LangGraph.

The Business Scenario: Processing a Car Insurance Claim

Consider a customer submitting the following claim through a mobile application:

"I was rear-ended at a stoplight yesterday. My bumper is crushed. Here are three photos and the police report."

Before making a decision, the system must complete several tasks.

Claim Intake

Extract structured information from:

Customer description
Uploaded images
Police report

Required information includes:

Incident date
Location
Damage description
Police report status

Policy Verification

Verify whether:

The policy is active
Collision coverage exists
The customer is eligible for reimbursement

Fraud and Damage Assessment

Analyze the claim for:

Inconsistent information
Missing documentation
Suspicious behavior
Estimated repair severity

Final Decision Routing

Based on previous findings:

Approve the claim
Reject the claim
Escalate to a human adjuster

Why a Single-Agent Approach Struggles

A common implementation is to provide a single LLM with one massive prompt containing:

Data extraction instructions
Database schemas
Fraud detection rules
Policy validation rules
Payout calculations

As the prompt grows, the model's attention becomes diluted.

The model must constantly switch between:

Reading images
Querying databases
Detecting fraud
Applying business rules

This often leads to:

Hallucinated outputs
Missed fraud indicators
Incorrect policy verification
Inconsistent decision-making

As workflows become more complex, maintaining reliability with a single agent becomes increasingly difficult.

Why Multi-Agent Systems Work Better

Instead of assigning every responsibility to one model, we divide the workflow into specialists.

Each agent receives:

A focused prompt
A narrow responsibility
A clean context window

For example:

Intake Agent → Data extraction
Policy Agent → Coverage verification
Fraud Agent → Risk analysis
Supervisor Agent → Final decision

This specialization improves:

Accuracy
Maintainability
Explainability
Debugging

Building the Multi-Agent Workflow with LangGraph

LangGraph is designed specifically for stateful AI workflows and multi-agent orchestration.

The framework revolves around two core concepts:

State
Nodes

The State acts as shared memory between agents.

Nodes represent specialized agents that read and update the State.

Step 1: Define the Shared State

In LangGraph, agents communicate through a shared state object.

Instead of directly communicating with one another, they read and update information stored in the State.

from typing import TypedDict, Literal, Annotated
from pydantic import BaseModel, Field
import operator

class ClaimDetails(BaseModel):
    incident_date: str
    location: str
    damage_description: str
    police_report_filed: bool

class AgentState(TypedDict):
    claim_id: str
    raw_input: str

    extracted_details: dict
    policy_status: str

    fraud_score: int
    fraud_flags: list

    final_decision: str

    next_agent: str
    messages: Annotated[list, operator.add]

Why State Matters

The State becomes the single source of truth for the entire workflow.

Every agent:

Reads existing information
Adds new information
Passes the updated State forward

This approach prevents information loss and makes troubleshooting significantly easier.

Step 2: Define Specialized Agents

Each node represents a dedicated specialist.

In production systems, each node would typically wrap a dedicated LLM with a highly focused system prompt.

Intake Agent

The Intake Agent is responsible only for extracting structured claim information.

def intake_agent(state: AgentState):
    """Extracts structured data from raw customer input."""

    raw = state["raw_input"]

    details = ClaimDetails(
        incident_date="2026-06-18",
        location="Main St & 5th Ave",
        damage_description="Rear bumper crushed",
        police_report_filed=True
    ).model_dump()

    return {
        "extracted_details": details,
        "messages": ["Intake Agent: Data extracted successfully."],
        "next_agent": "policy_agent"
    }

Responsibilities:

Parse customer text
Analyze uploaded documents
Extract incident details
Produce structured output

Policy Agent

The Policy Agent verifies coverage eligibility.

def policy_agent(state: AgentState):
    """Checks if the customer's policy covers the claim."""

    claim_id = state["claim_id"]

    if claim_id == "CLM-99":
        policy_status = "DENIED - Policy Lapsed"
    else:
        policy_status = "ACTIVE - Collision Coverage Confirmed"

    return {
        "policy_status": policy_status,
        "messages": [f"Policy Agent: Status is {policy_status}."],
        "next_agent": "fraud_agent"
    }

Responsibilities:

Query customer records
Validate coverage
Confirm eligibility

Fraud Assessment Agent

The Fraud Agent focuses solely on risk analysis.

def fraud_agent(state: AgentState):
    """Analyzes the claim for inconsistencies and fraud."""

    details = state["extracted_details"]

    flags = []
    fraud_score = 0

    if "crushed" in details["damage_description"] and not details["police_report_filed"]:
        flags.append("Major damage reported without police report.")
        fraud_score += 50

    return {
        "fraud_score": fraud_score,
        "fraud_flags": flags,
        "messages": [f"Fraud Agent: Score {fraud_score}. Flags: {flags}"],
        "next_agent": "supervisor"
    }

Responsibilities:

Detect suspicious patterns
Evaluate claim consistency
Calculate fraud risk

Supervisor Agent

The Supervisor Agent makes the final decision.

def supervisor_agent(state: AgentState):
    """Reviews all agent outputs and makes the final routing decision."""

    policy = state["policy_status"]
    fraud_score = state["fraud_score"]

    if "DENIED" in policy:
        decision = "REJECT_CLAIM"
    elif fraud_score >= 50:
        decision = "ESCALATE_TO_HUMAN"
    else:
        decision = "APPROVE_PAYOUT"

    return {
        "final_decision": decision,
        "messages": [f"Supervisor: Final decision is {decision}."],
        "next_agent": "END"
    }

Responsibilities:

Review all findings
Apply business rules
Route the workflow appropriately

Step 3: Build the LangGraph Workflow

Now we connect the specialized agents into a workflow.

from langgraph.graph import StateGraph, END

workflow = StateGraph(AgentState)

workflow.add_node("intake", intake_agent)
workflow.add_node("policy", policy_agent)
workflow.add_node("fraud", fraud_agent)
workflow.add_node("supervisor", supervisor_agent)

workflow.set_entry_point("intake")

Dynamic routing is controlled through the next_agent value stored in the State.

def route_to_next(state: AgentState):
    next_step = state.get("next_agent", "END")

    if next_step == "END":
        return END

    return next_step

Finally, compile the workflow.

app = workflow.compile()

At this point, the Multi-Agent system is fully operational.

Real-World Walkthrough

Let's follow a suspicious claim through the workflow.

Customer Submission:

"I hit a pole last week. Bumper is crushed. No police report."

Claim ID:

CLM-99

Step 1: Intake Agent

The Intake Agent extracts:

{
  "damage_description": "Rear bumper crushed",
  "police_report_filed": false
}

The updated State is passed to the Policy Agent.

Step 2: Policy Agent

The database lookup returns:

Policy Status: DENIED - Policy Lapsed

The State is updated and forwarded.

Step 3: Fraud Agent

The Fraud Agent identifies:

Major damage
No police report

Result:

Fraud Score: 50

Flag generated:

Major damage reported without police report.

Step 4: Supervisor Agent

The Supervisor reviews:

Policy Status: DENIED
Fraud Score: 50

Final Decision:

REJECT_CLAIM

The workflow ends.

Why This Is Better Than a Single Agent

In a Single-Agent architecture, the model must simultaneously:

Analyze damage
Validate policies
Detect fraud
Apply payout rules

This increases the risk of:

Hallucinations
Contradictory reasoning
Incorrect approvals

In a Multi-Agent architecture:

Policy validation remains isolated
Fraud detection remains isolated
Decision-making remains isolated

Each specialist focuses on one responsibility and performs it more reliably.

Single-Agent Systems

Best For

Chatbots
Simple workflows
Basic RAG applications

Advantages

Faster execution
Lower cost
Easier deployment

Challenges

Context overload
Harder debugging
Reduced accuracy in complex workflows

Multi-Agent Systems

Best For

Enterprise automation
Complex business processes
Multi-step workflows

Advantages

Better accuracy
Easier debugging
Greater scalability
Improved explainability

Challenges

Higher latency
Higher operational costs
More architectural complexity

Key Takeaways for AI Engineers

Start Simple

Always attempt to solve the problem using a Single-Agent architecture first.

Only move to Multi-Agent systems when:

Context becomes too large
Reliability decreases
Specialized reasoning is required

State Is the Glue

In LangGraph, agents communicate through State.

A well-designed State:

Prevents information loss
Simplifies debugging
Improves reliability

Use the Supervisor Pattern

For production systems, a Supervisor Agent provides:

Centralized decision-making
Dynamic routing
Early exits
Better governance

Specialization Reduces Hallucinations

The narrower an agent's responsibility, the more reliable its output becomes.

Just as hospitals rely on specialists instead of one doctor doing everything, AI systems often achieve better results when responsibilities are distributed across focused agents.

Conclusion

Single-Agent systems remain the best choice for many applications because they are simpler, faster, and cheaper.

However, as workflows become more complex, involve multiple tools, require specialized reasoning, or demand higher reliability, Multi-Agent architectures become increasingly valuable.

Frameworks such as LangGraph make it possible to orchestrate specialized AI agents through a shared State model, creating systems that are more modular, maintainable, and accurate.

The key lesson:

Use a Single Agent when the problem is simple. Use a Multi-Agent architecture when specialization, explainability, and workflow complexity demand it.