LangGraph vs CrewAI vs Claude Agent SDK: which AI agent framework to use

from langchain.chat_models import init_chat_model
from langchain.messages import SystemMessage, ToolMessage
from langchain.tools import tool
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.types import Command, interrupt

ORDERS = {"A-1042": "total 140.00, delivered 6 days late"}


@tool
def get_order(order_id: str) -> str:
    """Look up an order: its total and how it was delivered."""
    return ORDERS.get(order_id, "no such order")


@tool
def refund(order_id: str, amount: float) -> str:
    """Refund an amount on an order."""
    # Over 100, the graph stops here and waits for a person.
    if amount > 100 and not interrupt({"refund": order_id, "amount": amount}):
        return "A person declined this refund."
    return f"Refunded {amount:.2f} on {order_id}."


TOOLS = {t.name: t for t in (get_order, refund)}
model = init_chat_model("anthropic:claude-sonnet-5-5").bind_tools(list(TOOLS.values()))


def call_model(state: MessagesState):
    rules = SystemMessage("You handle refunds for a shop. Look up the order before you refund it.")
    return {"messages": [model.invoke([rules, *state["messages"]])]}


def run_tools(state: MessagesState):
    calls = state["messages"][-1].tool_calls
    return {"messages": [ToolMessage(TOOLS[c["name"]].invoke(c["args"]), tool_call_id=c["id"]) for c in calls]}


def next_step(state: MessagesState):
    return "tools" if state["messages"][-1].tool_calls else END


graph = StateGraph(MessagesState)
graph.add_node("model", call_model)
graph.add_node("tools", run_tools)
graph.add_edge(START, "model")
graph.add_conditional_edges("model", next_step, ["tools", END])
graph.add_edge("tools", "model")
agent = graph.compile(checkpointer=InMemorySaver())

run = {"configurable": {"thread_id": "order-A-1042"}}
result = agent.invoke({"messages": [("user", "Order A-1042 came late. Please refund it.")]}, run)
if "__interrupt__" in result:  # paused before the refund, its state saved
    result = agent.invoke(Command(resume=True), run)  # a person said yes
print(result["messages"][-1].content)

The loop is the edge from tools back to model. interrupt() saves the state and stops the run; the second invoke, with Command(resume=True) and the same thread_id, carries on where it stopped.

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

ORDERS = {"A-1042": "total 140.00, delivered 6 days late"}


@tool("Get order")
def get_order(order_id: str) -> str:
    """Look up an order: its total and how it was delivered."""
    return ORDERS.get(order_id, "no such order")


@tool("Refund")
def refund(order_id: str, amount: float) -> str:
    """Refund an amount on an order."""
    return f"Refunded {amount:.2f} on {order_id}."


checker = Agent(
    role="Order checker",
    goal="Find out what happened to an order",
    backstory="You read order records and report only what they say.",
    tools=[get_order],
    llm="anthropic/claude-sonnet-5-5",
)
refunder = Agent(
    role="Refund officer",
    goal="Refund what the shop's rules allow",
    backstory="A late order gets a full refund. Anything else gets none.",
    tools=[refund],
    llm="anthropic/claude-sonnet-5-5",
)

check = Task(
    description="Look up order {order_id}. The customer says: {complaint}",
    expected_output="The order's total and whether it came late.",
    agent=checker,
)
pay = Task(
    description="Refund order {order_id} if the shop's rules allow it.",
    expected_output="What was refunded, or why nothing was.",
    agent=refunder,
    context=[check],  # gets the checker's answer
)

crew = Crew(agents=[checker, refunder], tasks=[check, pay], process=Process.sequential)
print(crew.kickoff(inputs={"order_id": "A-1042", "complaint": "It came late."}))

2 agents, each holding only the tool its role needs; the refund officer gets the checker's answer through context. For the approval over 100, run the crew inside a Flow and put a @human_feedback step before the refund. human_input=True on a task is not a gate, because it asks for a review after the task's tools have run.

import asyncio
from typing import Any

from claude_agent_sdk import ClaudeAgentOptions, HookMatcher, ResultMessage, create_sdk_mcp_server, query, tool

ORDERS = {"A-1042": "total 140.00, delivered 6 days late"}


@tool("get_order", "Look up an order: its total and how it was delivered", {"order_id": str})
async def get_order(args: dict[str, Any]) -> dict[str, Any]:
    return {"content": [{"type": "text", "text": ORDERS.get(args["order_id"], "no such order")}]}


@tool("refund", "Refund an amount on an order", {"order_id": str, "amount": float})
async def refund(args: dict[str, Any]) -> dict[str, Any]:
    return {"content": [{"type": "text", "text": f"Refunded {args['amount']:.2f} on {args['order_id']}."}]}


shop = create_sdk_mcp_server(name="shop", version="1.0.0", tools=[get_order, refund])


# Runs before every refund call: over 100, a person must say yes.
async def approve_refund(input_data, tool_use_id, context):
    amount = input_data["tool_input"]["amount"]
    if amount > 100 and await asyncio.to_thread(input, f"Refund {amount:.2f}? y/n ") != "y":
        return {
            "hookSpecificOutput": {
                "hookEventName": input_data["hook_event_name"],
                "permissionDecision": "deny",
                "permissionDecisionReason": "A person declined this refund.",
            }
        }
    return {}


async def main():
    options = ClaudeAgentOptions(
        model="sonnet",
        system_prompt="You handle refunds for a shop. Look up the order before you refund it.",
        tools=[],  # none of Claude Code's own tools: no files, no shell
        mcp_servers={"shop": shop},
        allowed_tools=["mcp__shop__get_order", "mcp__shop__refund"],
        hooks={"PreToolUse": [HookMatcher(matcher="mcp__shop__refund", hooks=[approve_refund])]},
    )
    async for message in query(prompt="Order A-1042 came late. Please refund it.", options=options):
        if isinstance(message, ResultMessage):
            print(message.result)


asyncio.run(main())

Your tools become an in-process MCP server, so Claude sees them as mcp__shop__get_order and mcp__shop__refund. tools=[] removes Claude Code's own file and shell tools, and the PreToolUse hook runs before every refund call.