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

AI agent telah berpindah dari demo penelitian ke sistem production. Lebih dari 60% aplikasi AI enterprise diperkirakan akan mencakup komponen agentic pada tahun 2026. Namun membangun agent dari awal - mengelola tool loops, state, memory, error handling, dan koordinasi multi-agent - itu kompleks. Di sinilah framework berperan.

Empat framework mendominasi di 2026: LangGraph, CrewAI, OpenAI Agents SDK, dan Claude Agent SDK. Masing-masing mengambil pendekatan yang berbeda secara fundamental terhadap masalah yang sama: memberikan LLM kemampuan untuk bernalar, merencanakan, menggunakan tool, dan berkolaborasi.

Sekilas

LangGraph: Pembangun Graph

LangGraph memodelkan agent workflow sebagai directed cyclic graph. Anda mendefinisikan nodes (fungsi yang melakukan pekerjaan) dan edges (transisi di antara mereka, opsional kondisional). State mengalir melalui graph dan bertahan melalui checkpointing.

Ini adalah framework yang paling eksplisit dan terkontrol - Anda mengatur setiap langkah sendiri.

Konsep Inti

• StateGraph: definisi graph dengan state bertipe
• Nodes: fungsi Python yang mengubah state
• Edges: koneksi antar node, bisa bersyarat
• Checkpointing: persistence bawaan untuk workflow yang berjalan lama

Contoh Kode

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

• Kontrol halus atas setiap langkah dan transisi
• Checkpointing bawaan dan human-in-the-loop
• Paritas TypeScript penuh
• Bekerja dengan penyedia LLM apa pun
• Terbaik untuk workflow kompleks dengan conditional branching dan loops

Kelemahan

• Kurva pembelajaran curam - Anda perlu memahami konsep teori graph
• Bertele-tele untuk use case sederhana - agent dasar memerlukan lebih banyak boilerplate daripada framework lain
• Men-debug graph flow bisa menantang tanpa LangSmith

Harga

Open-source (MIT). LangSmith (platform observability terkelola) memiliki tier berbayar untuk production monitoring.

CrewAI: Perakit Tim

CrewAI mengambil metafora manusia: Anda merakit crew dari agent khusus, masing-masing dengan role, goal, dan backstory. Agent berkolaborasi pada task menggunakan tool, dikoordinasikan oleh process (sequential, hierarchical, atau consensual).

Anggap saja seperti merekrut tim di mana setiap anggota memiliki jabatan dan keahlian spesifik.

Konsep Inti

• Agent: persona dengan role, goal, backstory, dan tool
• Task: penugasan dengan deskripsi, output yang diharapkan, dan agent yang ditugaskan
• Crew: sekelompok agent yang bekerja bersama
• Process: strategi eksekusi (sequential, hierarchical, consensual)
• Flow: lapisan orkestrasi berbasis event untuk menghubungkan beberapa crew

Contoh Kode

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 berbasis role yang intuitif - mudah dipikirkan
• 100+ integrasi tool bawaan
• Memory bersama antar agent (short-term, long-term, entity)
• Komunitas terbesar (~40k GitHub stars)
• Hierarchical process dengan agent "manager" yang mendelegasikan dan memvalidasi

Kelemahan

• Kurang kontrol halus dibanding LangGraph - Anda mendefinisikan role, bukan jalur eksekusi yang tepat
• Hierarchical process bisa tidak dapat diprediksi ketika agent tidak setuju
• Men-debug percakapan multi-agent lebih sulit daripada single-agent flow

Harga

Core open-source (gratis). CrewAI Platform: $99/bulan (Teams) hingga $120k/tahun (Enterprise). Harga berdasarkan live crew dan eksekusi bulanan.

OpenAI Agents SDK: Sang Router

OpenAI Agents SDK (penerus spiritual Swarm) berfokus pada handoff - agent yang mentransfer percakapan ke agent khusus lainnya. Ini adalah framework paling minimal: agent, tool, handoff, dan guardrail. Hanya itu.

Konsep Inti

• Agent: model + instruksi + tool + handoff
• Handoff: transfer ke agent lain (dimodelkan sebagai tool yang bisa dipanggil LLM)
• Guardrail: validasi input/output yang berjalan paralel dengan agent
• Runner: menjalankan agent loop
• Tracing: observability bawaan untuk semua panggilan LLM, pemanggilan tool, dan handoff

Contoh Kode

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

• Pola handoff yang bersih - alami untuk workflow routing/triage
• Guardrail berjalan paralel dengan eksekusi (fail-fast, tidak memblokir)
• Dashboard tracing bawaan untuk debugging
• Meskipun namanya, mendukung model non-OpenAI
• Abstraksi minimal - mudah dipahami dan diperluas

Kelemahan

• Manajemen state kurang matang dibanding LangGraph
• Tidak ada persistence atau checkpointing bawaan
• Ekosistem tool pihak ketiga lebih kecil
• Desain yang berpusat pada handoff mungkin tidak cocok untuk setiap arsitektur

Harga

Open-source (MIT). Anda membayar per-token untuk model apa pun yang Anda gunakan.

Claude Agent SDK: Sang Developer

Claude Agent SDK mengambil pendekatan yang berbeda: alih-alih mendefinisikan workflow atau role, Anda memberi agent sekumpulan tool dan membiarkannya mencari cara untuk menyelesaikan tugas. Ini menggunakan autonomous loop yang sama yang menggerakkan Claude Code - baca, bertindak, verifikasi, iterasi.

Konsep Inti

• query(): entry point utama yang memulai agent loop
• Built-in tools: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Custom tools via MCP: mendefinisikan tool sebagai in-process MCP server
• Sub-agents: agent khusus yang bisa didelegasikan oleh parent
• Sessions: mempertahankan konteks di beberapa interaksi

Contoh Kode

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 satu - terhubung ke ekosistem MCP server apa pun
• Tool bawaan untuk operasi file, terminal, dan akses web
• Pemadatan konteks otomatis untuk codebase besar
• Paralelisme sub-agent untuk tugas kompleks
• Engine yang sama dengan Claude Code - teruji di workflow development nyata

Kelemahan

• Hanya model Claude - tidak ada dukungan multi-provider
• Framework lebih baru dengan komunitas lebih kecil
• Memerlukan runtime Node.js bahkan untuk Python SDK
• Kurang kontrol workflow eksplisit dibanding LangGraph

Harga

Open-source. Tarif token Claude API standar. Managed Agents (versi hosted): $0.08 per session-hour sebagai tambahan biaya token.

Kapan Memilih yang Mana

Pilih LangGraph jika:

• Anda membutuhkan kontrol presisi atas setiap langkah workflow
• Use case Anda melibatkan logika kondisional kompleks dan loop
• Anda ingin persistence bawaan dan checkpoint human-in-the-loop
• Anda perlu menggunakan beberapa penyedia LLM dalam workflow yang sama

Pilih CrewAI jika:

• Anda ingin abstraksi berbasis role yang intuitif
• Tugas Anda melibatkan beberapa agent dengan spesialisasi berbeda
• Anda membutuhkan agent untuk berkolaborasi dan meneruskan konteks satu sama lain
• Anda menghargai komunitas terbesar dan integrasi bawaan terbanyak

Pilih OpenAI Agents SDK jika:

• Pola utama Anda adalah merutekan percakapan ke spesialis
• Anda butuh guardrail yang memvalidasi input/output secara paralel
• Anda ingin abstraksi sesederhana mungkin dengan boilerplate minimal
• Tracing dan observability bawaan penting

Pilih Claude Agent SDK jika:

• Agent Anda perlu membaca, menulis, dan mengeksekusi kode
• Anda ingin integrasi MCP server kelas satu
• Anda membutuhkan agent autonomous yang beriterasi dan mengoreksi diri
• Anda sudah menggunakan Claude dan ingin integrasi terdalam

Bisakah Anda Menggabungkan Framework?

Ya. Pola umum adalah menggunakan satu framework untuk orkestrasi dan lainnya untuk agent individual:

• LangGraph untuk graph workflow keseluruhan
• CrewAI untuk node spesifik yang membutuhkan kolaborasi multi-agent
• Claude Agent SDK untuk sub-tugas terkait coding via MCP
• OpenAI Agents SDK untuk triage dan routing yang menghadap pelanggan

Framework tidak saling eksklusif. Gunakan apa yang sesuai untuk setiap bagian sistem Anda.

Kesimpulan

Setiap framework membuat taruhan yang jelas:

• LangGraph dioptimalkan untuk kontrol - Anda yang memutuskan setiap transisi
• CrewAI dioptimalkan untuk kolaborasi - agent bekerja sebagai tim
• OpenAI Agents SDK dioptimalkan untuk kesederhanaan - abstraksi minimal, handoff yang bersih
• Claude Agent SDK dioptimalkan untuk otonomi - beri tool dan biarkan bekerja

Pilihan yang tepat tergantung pada workflow, tim, dan stack Anda yang ada. Pilih yang cocok dengan use case utama Anda, pelajari dengan baik, dan tarik yang lain saat Anda mencapai sweet spot mereka.