LangGraph Alternatives for Agent Orchestration: What We Learned Running All of Them

from dataclasses import dataclass
from typing import Optional
from pydantic import BaseModel, Field


class OrderDetails(BaseModel):
    order_id: str
    status: str
    days_delayed: int
    base_shipping_cost: float


class RemediationOutput(BaseModel):
    summary: str = Field(description="Operational summary of the resolution")
    refund_amount: float = Field(description="Total monetary refund awarded")
    action_required: bool = Field(description="Whether human intervention is needed")
    status_code: str = Field(description="Internal operational status code")


def lookup_order_status(order_id: str) -> dict:
    """Retrieves order logistics, status, and shipping metrics."""
    database = {
        "ORD-8821": {"order_id": "ORD-8821", "status": "delayed", "days_delayed": 4, "base_shipping_cost": 29.50},
        "ORD-4410": {"order_id": "ORD-4410", "status": "delivered", "days_delayed": 0, "base_shipping_cost": 15.00},
    }
    return database.get(order_id, {"error": "Order identifier not found"})


def calculate_shipping_refund(days_delayed: int, base_cost: float) -> float:
    """Calculates eligible customer compensation based on delivery delay."""
    if days_delayed <= 1:
        return 0.0
    elif 2 <= days_delayed <= 3:
        return round(base_cost * 0.5, 2)
    return round(base_cost * 1.0, 2)

from crewai import Agent, Task, Crew, Process
from crewai.tools import tool

@tool("Order Lookup")
def order_lookup_tool(order_id: str) -> str:
    """Lookup order status by identifier."""
    return str(lookup_order_status(order_id))

@tool("Refund Calculation")
def refund_calc_tool(days_delayed: int, base_cost: float) -> str:
    """Calculate refund based on delay and cost."""
    return str(calculate_shipping_refund(days_delayed, base_cost))

triage_agent = Agent(
    role="Order Resolution Specialist",
    goal="Triage customer orders and calculate accurate refunds.",
    backstory="Senior support engineer dedicated to fair customer compensation.",
    tools=[order_lookup_tool, refund_calc_tool],
    verbose=False
)

remediation_task = Task(
    description="Analyze order {order_id}. Determine delays and compute refunds.",
    expected_output="Structured remediation summary matching corporate policy.",
    agent=triage_agent
)

crew = Crew(
    agents=[triage_agent],
    tasks=[remediation_task],
    process=Process.sequential
)

result = crew.kickoff(inputs={"order_id": "ORD-8821"})

import os
from autogen import AssistantAgent, UserProxyAgent, register_function

llm_config = {
    "config_list": [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}],
    "temperature": 0.0,
}

assistant = AssistantAgent(
    name="RemediationAssistant",
    system_message="Calculate shipping refunds. Call lookup then calculate. Reply TERMINATE when finished.",
    llm_config=llm_config,
)

user_proxy = UserProxyAgent(
    name="ExecutionProxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=3,
    is_termination_msg=lambda x: "TERMINATE" in (x.get("content") or ""),
    code_execution_config=False,
)

register_function(
    lookup_order_status,
    caller=assistant,
    executor=user_proxy,
    name="lookup_order_status",
    description="Fetch order status",
)

register_function(
    calculate_shipping_refund,
    caller=assistant,
    executor=user_proxy,
    name="calculate_shipping_refund",
    description="Compute refund",
)

user_proxy.initiate_chat(
    assistant,
    message="Process delayed shipment remediation for order ORD-8821.",
)

from agno.agent import Agent
from agno.models.openai import OpenAIChat

order_agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    tools=[lookup_order_status, calculate_shipping_refund],
    response_model=RemediationOutput,
    instructions=[
        "Lookup the order status by ID.",
        "Calculate the refund if delayed.",
        "Return the final structured remediation output."
    ],
    markdown=False
)

response = order_agent.run("Process delayed shipment remediation for order ORD-8821.")

from pydantic_ai import Agent, RunContext
from dataclasses import dataclass

@dataclass
class TriageContext:
    service_tier: str = "Enterprise"

agent = Agent(
    "openai:gpt-4o",
    deps_type=TriageContext,
    result_type=RemediationOutput,
    system_prompt="Resolve order shipping delays using provided tools."
)

@agent.tool
def tool_order_lookup(ctx: RunContext[TriageContext], order_id: str) -> dict:
    """Fetch order status by order_id."""
    return lookup_order_status(order_id)

@agent.tool
def tool_calculate_refund(ctx: RunContext[TriageContext], days_delayed: int, base_cost: float) -> float:
    """Calculate the shipping refund amount."""
    return calculate_shipping_refund(days_delayed, base_cost)

result = agent.run_sync(
    "Evaluate refund for customer order ORD-8821.",
    deps=TriageContext()
)

from agents import Agent, Runner, function_tool

@function_tool
def fetch_order(order_id: str) -> dict:
    """Lookup order status."""
    return lookup_order_status(order_id)

@function_tool
def calculate_refund(days_delayed: int, base_cost: float) -> float:
    """Compute refund based on delay."""
    return calculate_shipping_refund(days_delayed, base_cost)

remediation_agent = Agent(
    name="RemediationSpecialist",
    instructions="Resolve delayed orders using available tools and summarize remediation.",
    tools=[fetch_order, calculate_refund],
    output_type=RemediationOutput
)

result = Runner.run_sync(
    remediation_agent,
    "Remediate delayed customer shipment for ORD-8821."
)

from llama_index.core.workflow import Workflow, StartEvent, StopEvent, step, Event
from llama_index.llms.openai import OpenAI

class OrderLookupEvent(Event):
    order_id: str

class CalculationEvent(Event):
    days_delayed: int
    base_cost: float

class RemediationWorkflow(Workflow):
    @step
    async def extract_and_route(self, ev: StartEvent) -> OrderLookupEvent:
        return OrderLookupEvent(order_id="ORD-8821")

    @step
    async def fetch_status(self, ev: OrderLookupEvent) -> CalculationEvent:
        order_data = lookup_order_status(ev.order_id)
        return CalculationEvent(
            days_delayed=order_data["days_delayed"],
            base_cost=order_data["base_shipping_cost"]
        )

    @step
    async def compute_remediation(self, ev: CalculationEvent) -> StopEvent:
        refund = calculate_shipping_refund(ev.days_delayed, ev.base_cost)
        summary = f"Refund of ${refund} processed for {ev.days_delayed} days delay."
        return StopEvent(result={"summary": summary, "refund_amount": refund})

workflow = RemediationWorkflow(timeout=30)

{
  "nodes": [
    {
      "parameters": {
        "options": {
          "systemMessage": "You evaluate order delays and calculate refunds using tools."
        }
      },
      "name": "AI Agent Node",
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 1.7,
      "position": [460, 240]
    },
    {
      "parameters": {
        "model": "gpt-4o"
      },
      "name": "OpenAI Chat Model",
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
      "position": [460, 460]
    },
    {
      "parameters": {
        "name": "lookup_order",
        "description": "Fetch order status by order ID",
        "jsCode": "return JSON.stringify(lookup_order_status(query));"
      },
      "name": "Custom Code Tool",
      "type": "@n8n/n8n-nodes-langchain.toolCode",
      "position": [680, 380]
    }
  ]
}