Perbandingan Framework Agentic AI: LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

AI agent telah beralih daripada demo penyelidikan ke sistem production. Lebih 60% aplikasi AI enterprise dijangka akan merangkumi komponen agentic menjelang 2026. Tetapi membina agent dari awal - menguruskan tool loops, state, memory, error handling, dan penyelarasan multi-agent - adalah kompleks. Di sinilah framework memainkan peranan.

Empat framework mendominasi pada 2026: LangGraph, CrewAI, OpenAI Agents SDK, dan Claude Agent SDK. Setiap satu mengambil pendekatan yang berbeza secara asasnya terhadap masalah yang sama: memberikan LLM keupayaan untuk menaakul, merancang, menggunakan tool, dan bekerjasama.

Sepintas Lalu

LangGraph: Pembina Graph

LangGraph memodelkan agent workflow sebagai directed cyclic graphs. Anda mentakrifkan nodes (fungsi yang melakukan kerja) dan edges (transisi antara mereka, pilihan bersyarat). State mengalir melalui graph dan berkekalan melalui checkpointing.

Ini adalah framework yang paling eksplisit dan boleh dikawal - anda menyambung setiap langkah sendiri.

Konsep Utama

• StateGraph: definisi graph dengan state bertaip
• Nodes: fungsi Python yang mengubah state
• Edges: sambungan antara nodes, boleh bersyarat
• Checkpointing: persistence terbina dalam untuk workflow jangka panjang

Contoh Kod

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def call_agent(state: MessagesState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

def call_tools(state: MessagesState):
    # Execute tool calls and return results
    results = []
    for tool_call in state["messages"][-1].tool_calls:
        result = execute_tool(tool_call)
        results.append(result)
    return {"messages": results}

graph = StateGraph(MessagesState)
graph.add_node("agent", call_agent)
graph.add_node("tools", call_tools)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})

Kekuatan

• Kawalan halus ke atas setiap langkah dan transisi
• Checkpointing terbina dalam dan human-in-the-loop
• Pariti TypeScript penuh
• Berfungsi dengan mana-mana penyedia LLM
• Terbaik untuk workflow kompleks dengan conditional branching dan loops

Kelemahan

• Keluk pembelajaran curam - anda perlu memahami konsep teori graph
• Meleret untuk use case mudah - agent asas memerlukan lebih banyak boilerplate daripada framework lain
• Nyahpepijat aliran graph boleh mencabar tanpa LangSmith

Harga

Open-source (MIT). LangSmith (platform observability terurus) mempunyai tier berbayar untuk pemantauan production.

CrewAI: Pemasang Pasukan

CrewAI mengambil metafora manusia: anda memasang crew ejen khusus, setiap satu dengan role, goal, dan backstory. Ejen bekerjasama pada tasks menggunakan tools, diselaraskan oleh process (sequential, hierarchical, atau consensual).

Fikirkannya seperti mengupah pasukan di mana setiap ahli mempunyai jawatan dan kepakaran tertentu.

Konsep Utama

• Agent: persona dengan role, goal, backstory, dan tools
• Task: tugasan dengan penerangan, output yang dijangka, dan agent yang ditugaskan
• Crew: sekumpulan ejen yang bekerjasama
• Process: strategi pelaksanaan (sequential, hierarchical, consensual)
• Flow: lapisan orkestra berasaskan peristiwa untuk menghubungkan beberapa crew

Contoh Kod

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive data about the given topic",
    backstory="You have 10 years of experience in technology research. "
              "You are thorough and always verify facts from multiple sources.",
    tools=[web_search_tool],
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging technical content",
    backstory="You write for a developer audience. "
              "Your articles are practical and include code examples.",
    tools=[file_tool],
    verbose=True,
)

research_task = Task(
    description="Research the latest developments in WebAssembly in 2026. "
                "Focus on WASI, Component Model, and production use cases.",
    expected_output="A structured research document with key findings and sources.",
    agent=researcher,
)

writing_task = Task(
    description="Write a blog post based on the research. "
                "Include code examples and Mermaid diagrams.",
    expected_output="A complete blog post in Markdown format.",
    agent=writer,
    context=[research_task],  # Writer receives researcher's output
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Kekuatan

• Abstraksi berasaskan role yang intuitif - mudah untuk difikirkan
• 100+ integrasi tool terbina dalam
• Memory dikongsi antara ejen (jangka pendek, jangka panjang, entiti)
• Komuniti terbesar (~40k GitHub stars)
• Hierarchical process dengan agent "manager" yang mewakilkan dan mengesahkan

Kelemahan

• Kurang kawalan halus berbanding LangGraph - anda mentakrifkan roles, bukan laluan pelaksanaan yang tepat
• Hierarchical process boleh menjadi tidak dapat diramal apabila ejen tidak bersetuju
• Nyahpepijat perbualan multi-agent lebih sukar daripada aliran single-agent

Harga

Teras open-source (percuma). CrewAI Platform: $99/bulan (Teams) sehingga $120k/tahun (Enterprise). Harga berdasarkan live crew dan pelaksanaan bulanan.

OpenAI Agents SDK: Sang Router

OpenAI Agents SDK (pengganti rohani Swarm) memberi tumpuan kepada handoffs - ejen yang memindahkan perbualan kepada ejen khusus lain. Ia adalah framework paling minimum: agents, tools, handoffs, dan guardrails. Itu sahaja.

Konsep Utama

• Agent: model + arahan + tools + handoffs
• Handoff: pemindahan kepada ejen lain (dimodelkan sebagai tool yang boleh dipanggil LLM)
• Guardrail: pengesahan input/output yang berjalan selari dengan agent
• Runner: melaksanakan agent loop
• Tracing: observability terbina dalam untuk semua panggilan LLM, pemanggilan tool, dan handoffs

Contoh Kod

from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel

class SafetyCheck(BaseModel):
    is_safe: bool
    reason: str

async def content_safety(ctx, agent, input_text):
    result = await Runner.run(
        Agent(name="Safety", instructions="Check if input is safe. No PII."),
        input_text,
        context=ctx,
    )
    output = SafetyCheck.model_validate_json(result.final_output)
    return GuardrailFunctionOutput(
        output_info=output, tripwire_triggered=not output.is_safe
    )

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing inquiries. Be precise with numbers.",
    tools=[lookup_invoice, process_payment],
)

refund_agent = Agent(
    name="Refund Agent",
    instructions="You process refund requests. Always verify the order first.",
    tools=[lookup_order, issue_refund],
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route the customer to the right specialist. "
                 "Ask clarifying questions if needed.",
    handoffs=[billing_agent, refund_agent],
    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
)

result = await Runner.run(triage_agent, "I need a refund for order #4521")
print(result.final_output)
# The triage agent routes to refund_agent, which processes the refund

Kekuatan

• Corak handoff yang bersih - semula jadi untuk workflow routing/triage
• Guardrails berjalan selari dengan pelaksanaan (fail-fast, bukan menyekat)
• Dashboard tracing terbina dalam untuk debugging
• Walaupun namanya, menyokong model bukan OpenAI
• Abstraksi minimum - mudah difahami dan dikembangkan

Kelemahan

• Pengurusan state kurang matang berbanding LangGraph
• Tiada persistence atau checkpointing terbina dalam
• Ekosistem tool pihak ketiga lebih kecil
• Reka bentuk berpusatkan handoff mungkin tidak sesuai untuk setiap seni bina

Harga

Open-source (MIT). Anda membayar per-token untuk mana-mana model yang anda gunakan.

Claude Agent SDK: Sang Developer

Claude Agent SDK mengambil pendekatan berbeza: daripada mentakrifkan workflow atau roles, anda memberi agent satu set tools dan biarkan ia memikirkan cara menyelesaikan tugasan. Ia menggunakan autonomous loop yang sama yang menggerakkan Claude Code - baca, bertindak, sahkan, ulangi.

Konsep Utama

• query(): titik masuk utama yang memulakan agent loop
• Built-in tools: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Custom tools via MCP: takrifkan tools sebagai MCP server dalam proses
• Sub-agents: ejen khusus yang boleh diwakilkan oleh parent
• Sessions: mengekalkan konteks merentasi pelbagai interaksi

Contoh Kod

import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const searchDocs = tool(
  "search_docs",
  "Search the internal documentation for relevant information",
  { query: z.string().describe("Search query") },
  async ({ query }) => {
    const results = await vectorStore.similaritySearch(query, 5);
    return {
      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
    };
  }
);

const docsServer = createSdkMcpServer({
  name: "docs",
  version: "1.0.0",
  tools: [searchDocs],
});

for await (const message of query({
  prompt: "Find how authentication works in our system and write a summary",
  options: {
    mcpServers: { docs: docsServer },
    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
  },
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

Kekuatan

• Integrasi MCP kelas pertama - sambung ke mana-mana ekosistem MCP server
• Tools terbina dalam untuk operasi fail, terminal, dan akses web
• Pemadatan konteks automatik untuk codebase besar
• Keselarian sub-agent untuk tugas kompleks
• Enjin yang sama dengan Claude Code - teruji pertempuran pada workflow development sebenar

Kelemahan

• Model Claude sahaja - tiada sokongan multi-provider
• Framework lebih baharu dengan komuniti lebih kecil
• Memerlukan Node.js runtime walaupun untuk Python SDK
• Kurang kawalan workflow eksplisit berbanding LangGraph

Harga

Open-source. Kadar token Claude API standard. Managed Agents (versi dihoskan): $0.08 setiap session-hour sebagai tambahan kepada kos token.

Bila Memilih Yang Mana

Pilih LangGraph jika:

• Anda memerlukan kawalan tepat ke atas setiap langkah workflow
• Use case anda melibatkan logik bersyarat kompleks dan loops
• Anda mahukan persistence terbina dalam dan human-in-the-loop checkpoint
• Anda perlu menggunakan beberapa penyedia LLM dalam workflow yang sama

Pilih CrewAI jika:

• Anda mahukan abstraksi berasaskan role yang intuitif
• Tugas anda melibatkan beberapa ejen dengan kepakaran berbeza
• Anda memerlukan ejen untuk bekerjasama dan menghantar konteks antara satu sama lain
• Anda menghargai komuniti terbesar dan integrasi terbina dalam yang paling banyak

Pilih OpenAI Agents SDK jika:

• Corak utama anda ialah menghalakan perbualan kepada pakar
• Anda memerlukan guardrails yang mengesahkan input/output secara selari
• Anda mahukan abstraksi paling mudah yang mungkin dengan boilerplate minimum
• Tracing dan observability terbina dalam adalah penting

Pilih Claude Agent SDK jika:

• Ejen anda perlu membaca, menulis, dan melaksanakan kod
• Anda mahukan integrasi MCP server kelas pertama
• Anda memerlukan ejen autonomous yang beriterasi dan membetulkan diri
• Anda sudah menggunakan Claude dan mahukan integrasi terdalam

Bolehkah Anda Menggabungkan Framework?

Ya. Corak biasa ialah menggunakan satu framework untuk orkestra dan satu lagi untuk ejen individu:

• LangGraph untuk graph workflow keseluruhan
• CrewAI untuk node tertentu yang memerlukan kerjasama multi-agent
• Claude Agent SDK untuk sub-tugas berkaitan coding melalui MCP
• OpenAI Agents SDK untuk triage dan routing yang menghadap pelanggan

Framework tidak saling eksklusif. Gunakan apa yang sesuai untuk setiap bahagian sistem anda.

Kesimpulan

Setiap framework membuat pertaruhan yang jelas:

• LangGraph dioptimumkan untuk kawalan - anda memutuskan setiap transisi
• CrewAI dioptimumkan untuk kerjasama - ejen bekerja sebagai pasukan
• OpenAI Agents SDK dioptimumkan untuk kesederhanaan - abstraksi minimum, handoffs bersih
• Claude Agent SDK dioptimumkan untuk autonomi - beri ia tools dan biarkan ia bekerja

Pilihan yang tepat bergantung pada workflow anda, pasukan anda, dan stack sedia ada anda. Pilih yang sepadan dengan use case utama anda, pelajarinya dengan baik, dan tarik yang lain apabila anda mencapai sweet spot mereka.