Ringkasan Utama
LangGraph cocok untuk agent produksi yang harus berhenti menunggu persetujuan, bertahan saat restart, dan melanjutkan dari checkpoint, karena state, edge dan persistence ditulis eksplisit. CrewAI cocok untuk tim agent berbasis peran dan lebih cepat menghasilkan versi pertama; Flows menambah persistence dan human feedback, tetapi feedback bawaannya memblokir input console sampai Anda memasang provider.
Bayangkan agent accounts payable untuk sebuah distributor di Indonesia. Agent ini membaca PDF invoice supplier, membandingkan totalnya dengan purchase order di ERP, lalu membuat draft invoice. Sebagian besar invoice cocok. Yang selisihnya lebih dari dua persen perlu disetujui seseorang, dan orang itu bisa saja baru menjawab empat jam kemudian dari ponselnya, setelah server di-redeploy dua kali.
Kalimat terakhir itulah tempat pilihan LangGraph vs CrewAI sebenarnya ditentukan. Artikel ini membangun workflow tiga langkah yang sama di kedua framework, hanya dengan API dari dokumentasi terbaru mereka: LangGraph 1.x, yang rilis 1.0-nya pada Oktober 2025 menjadi versi major stabil pertamanya, dan CrewAI, yang dokumentasinya saat ini mengarah ke versi 1.15.23. Perbandingannya mencakup model kontrol, durable execution, persetujuan manusia, observability, platform managed, dan kurva belajar.
LangGraph vs CrewAI: jawaban singkatnya
Keduanya framework Python open-source dan keduanya sanggup menjalankan workflow ini. Bedanya ada pada apa yang dibuat eksplisit. LangGraph meminta Anda menggambar graph dan memberi checkpoint setelah setiap langkah. CrewAI meminta Anda mendeskripsikan agent lewat peran dan tujuan, lalu menyediakan Flows saat langkah-langkahnya perlu dikunci.
| Dimensi | LangGraph | CrewAI |
|---|---|---|
| Model kontrol | StateGraph berisi node dan edge. Setiap transisi adalah kode yang Anda tulis, termasuk routing kondisional lewat Command(goto=...). | Crew berisi agent berbasis peran yang berjalan berurutan atau di bawah manager agent, diorkestrasi oleh Flows berbasis event dengan decorator start, listen dan router. |
| State | Schema bertipe, biasanya TypedDict, digabung dari return value setiap node dan ditulis oleh checkpointer. | Model Pydantic atau dict pada Flow, dengan field id yang ditambahkan otomatis. |
| Durable execution | Checkpointer untuk Postgres, SQLite, MongoDB dan Cosmos DB, ditambah durability mode exit, async dan sync. | Decorator persist, dengan SQLiteFlowPersistence sebagai default, di level class atau method. |
| Resume | Invoke ulang dengan thread_id yang sama. Node yang terhenti dijalankan lagi dari baris pertamanya. | Kickoff dengan state id tersimpan untuk melanjutkan, atau restore_from_state_id untuk fork run baru. |
| Human-in-the-loop | interrupt() di dalam node mengembalikan payload; Command(resume=...) memberikan jawabannya. | Decorator human_feedback; default lewat input console, provider untuk penggunaan non-blocking, lalu resume(). |
| Riwayat dan replay | get_state_history menampilkan setiap checkpoint; resume dari checkpoint_id memutar ulang mulai titik itu. | Fork run baru dari state id tersimpan; dokumentasi Flows tidak menjelaskan riwayat checkpoint per langkah. |
| Observability dan platform | Tracing ke LangSmith; LangSmith Deployment menjalankan graph sebagai layanan managed. | Tracing bawaan ke CrewAI AMP, flow.plot() untuk diagram HTML; AMP meng-host crew dan flow. |
| Kurva belajar | Lebih curam. Anda memikirkan bentuk state, edge dan replay sebelum run pertama yang berguna. | Lebih landai. Role, goal dan backstory terbaca seperti deskripsi pekerjaan, jadi crew pertama cukup singkat. |
Kalau bentuk workflow-nya tetap, ada uang yang dipertaruhkan, dan ada manusia di tengahnya, sifat eksplisit LangGraph sepadan dengan usahanya. Kalau pekerjaannya riset atau drafting yang terbuka, di mana agent sebaiknya memutuskan di antara mereka sendiri, crew CrewAI lebih alami, dan Flows memungkinkan Anda menambah struktur di sekelilingnya tanpa pindah framework.
Graph versus crew dan flow: siapa yang menentukan langkah berikutnya
LangGraph menyebut dirinya runtime orkestrasi low-level, dan istilah low-level itu tepat. Node adalah fungsi yang menerima state dan mengembalikan update. Edge adalah garis yang Anda tambahkan. Saat model yang harus memilih, Anda tetap yang menentukan pilihannya, dengan mengembalikan Command yang menyebut node berikutnya. Tidak ada yang bergerak tanpa Anda sambungkan, dan itulah yang membuat graph bisa diaudit.
CrewAI berangkat dari arah sebaliknya. Crew adalah sekumpulan agent dengan role, goal dan backstory, yang mengerjakan task secara berurutan atau di bawah manager agent yang mendelegasikan dan memeriksa hasil. Flows ditambahkan untuk kasus di mana otonomi adalah default yang salah: isinya method Python biasa yang dirangkai dengan start, listen dan router, dan satu method Flow bisa menjalankan seluruh crew. Untuk pipeline invoice, Anda akhirnya menulis sebagian besar kode Flow dengan satu agent di dalamnya, tanda bahwa masalahnya memang berbentuk graph.
Workflow invoice di LangGraph
Tiga langkah: ekstrak field dengan panggilan model ber-structured output, cocokkan total dengan purchase order, lalu buat draft atau berhenti untuk persetujuan. Toleransi dan fungsi helper ERP hanya ilustrasi; pemanggilan LangGraph-nya sesuai dokumentasi.
from typing import Literal, TypedDict
from langchain.chat_models import init_chat_model
from langgraph.checkpoint.postgres import PostgresSaver
from langgraph.graph import END, START, StateGraph
from langgraph.types import Command, interrupt
from pydantic import BaseModel
class InvoiceFields(BaseModel):
vendor_code: str
po_number: str
total_idr: int
class InvoiceState(TypedDict, total=False):
raw_text: str
fields: InvoiceFields
variance_pct: float
erp_doc_id: str
llm = init_chat_model("openai:gpt-4.1-mini").with_structured_output(InvoiceFields)
TOLERANCE_PCT = 2.0 # example policy: above this, a person signs off
def extract(state: InvoiceState) -> InvoiceState:
return {"fields": llm.invoke(state["raw_text"])}
def match_po(state: InvoiceState) -> Command[Literal["approve", "post"]]:
po_total = erp.get_po_total(state["fields"].po_number) # read-only
variance = abs(state["fields"].total_idr - po_total) / po_total * 100
nxt = "approve" if variance > TOLERANCE_PCT else "post"
return Command(update={"variance_pct": variance}, goto=nxt)
def approve(state: InvoiceState) -> Command[Literal["post", "__end__"]]:
# Nothing with a side effect above this line: on resume the whole
# node runs again from the top, not from the interrupt() call.
decision = interrupt({
"po": state["fields"].po_number,
"variance_pct": round(state["variance_pct"], 2),
})
return Command(goto="post" if decision == "approve" else END)
def post(state: InvoiceState) -> InvoiceState:
# Idempotency key = PO number: a replayed node finds the existing draft.
doc_id = erp.create_draft_invoice(state["fields"], key=state["fields"].po_number)
return {"erp_doc_id": doc_id}
builder = StateGraph(InvoiceState)
builder.add_node(extract)
builder.add_node(match_po)
builder.add_node(approve)
builder.add_node(post)
builder.add_edge(START, "extract")
builder.add_edge("extract", "match_po")
builder.add_edge("post", END)
with PostgresSaver.from_conn_string(DB_URI) as checkpointer:
checkpointer.setup() # creates the checkpoint tables once
graph = builder.compile(checkpointer=checkpointer)
# thread_id is the checkpoint primary key: make it the business key.
config = {"configurable": {"thread_id": "inv-2026-10-0042"}}
result = graph.invoke({"raw_text": pdf_text}, config, durability="sync")
if "__interrupt__" in result:
notify_approver(result["__interrupt__"]) # hours may pass here
# Later, from the approval webhook, in any process:
graph.invoke(Command(resume="approve"), config)Dua detail memikul sebagian besar beban produksi. thread_id adalah primary key checkpointer, jadi memakai nomor invoice membuat setiap run mudah ditemukan oleh orang yang menanyakannya. Selain itu, pemanggilan resume tidak butuh proses aslinya: worker mana pun dengan checkpointer dan thread_id yang sama bisa melanjutkan dari titik graph berhenti, persis yang dibutuhkan persetujuan yang datang empat jam kemudian.
Workflow yang sama di CrewAI Flows
Versi Flow-nya setara langkah demi langkah. Extractor adalah satu Agent dengan response format Pydantic, pencocokan adalah router yang mengembalikan label, dan persetujuan memakai decorator human_feedback yang meng-emit salah satu outcome yang didaftarkan. Argumen llm membuat reviewer bisa mengetik teks bebas, lalu model mengklasifikasikannya menjadi approved atau rejected.
from crewai.agent import Agent
from crewai.flow.flow import Flow, listen, router, start
from crewai.flow.human_feedback import HumanFeedbackResult, human_feedback
from crewai.flow.persistence import persist
from pydantic import BaseModel
class InvoiceFields(BaseModel):
vendor_code: str
po_number: str
total_idr: int
class InvoiceState(BaseModel):
raw_text: str = ""
fields: InvoiceFields | None = None
variance_pct: float = 0.0
erp_doc_id: str = ""
TOLERANCE_PCT = 2.0
@persist # SQLiteFlowPersistence by default: state saved per method
class InvoiceFlow(Flow[InvoiceState]):
@start()
async def extract(self):
clerk = Agent(
role="AP clerk",
goal="Read supplier invoices into structured fields",
backstory="Indonesian supplier invoices, amounts in rupiah.",
)
result = await clerk.kickoff_async(self.state.raw_text, response_format=InvoiceFields)
self.state.fields = result.pydantic
@router(extract)
def match_po(self):
po_total = erp.get_po_total(self.state.fields.po_number)
self.state.variance_pct = abs(self.state.fields.total_idr - po_total) / po_total * 100
return "needs_review" if self.state.variance_pct > TOLERANCE_PCT else "auto_post"
@listen("needs_review")
@human_feedback(
message="Variance above tolerance. Approve posting this invoice?",
emit=["approved", "rejected"],
llm="gpt-4.1-mini", # maps free-text feedback onto an outcome
default_outcome="rejected", # silence never posts an invoice
)
def request_review(self):
return f"PO {self.state.fields.po_number}: {self.state.variance_pct:.2f}% over"
@listen("auto_post")
def post_clean(self):
self._post()
@listen("approved")
def post_approved(self, result: HumanFeedbackResult):
self._post()
@listen("rejected")
def park(self, result: HumanFeedbackResult):
erp.flag_for_ap_team(self.state.fields.po_number, result.feedback)
def _post(self):
self.state.erp_doc_id = erp.create_draft_invoice(
self.state.fields, key=self.state.fields.po_number
)
flow = InvoiceFlow()
flow.kickoff(inputs={"raw_text": pdf_text})
# Resume the same run later: InvoiceFlow().kickoff(inputs={"id": saved_state_id})
# Fork a new run from it: InvoiceFlow().kickoff(restore_from_state_id=saved_state_id)Kodenya lebih mirip Python biasa dibanding graph, dan bagi tim yang baru mengenal agent hal itu penting. Konsekuensinya, dua hal yang di LangGraph sudah tersedia menjadi tanggung jawab Anda: memilih backend persistence selain file SQLite default, dan memastikan langkah persetujuan tidak memblokir worker, yang dibahas di bagian berikutnya.
Durable execution: dari mana setiap framework mengulang
Kedua framework menyimpan state, tetapi granularitas restart-nya berbeda, dan perbedaan itu menentukan di mana side effect harus diletakkan.
- LangGraph menyimpan checkpoint per langkah. Dengan durability sync, checkpoint ditulis sebelum langkah berikutnya mulai; async menulisnya sambil langkah berikutnya berjalan; exit hanya menyimpan saat graph selesai, error atau interrupt, sehingga crash di tengah run menghilangkan langkah-langkah antaranya.
- Saat resume, LangGraph menjalankan ulang node yang terhenti dari baris pertamanya, bukan dari pemanggilan interrupt(). Setiap panggilan API atau penulisan database di atas interrupt akan berjalan lagi.
- CrewAI menyimpan state Flow lewat persist dan memulihkannya saat Anda kickoff dengan state id yang sama. Memulihkan dengan restore_from_state_id justru memuat snapshot dengan id baru, berguna untuk menjalankan ulang skenario tanpa menyentuh record aslinya.
Untuk workflow back-office, aturan praktisnya sama di keduanya: apa pun yang menulis ke ERP harus idempotent, dengan key berupa identitas bisnis seperti nomor PO atau invoice, supaya langkah yang diputar ulang menemukan draft yang sudah dibuat alih-alih membuat draft kedua. Pilih durability sync di LangGraph kalau kehilangan satu langkah lebih mahal daripada langkah yang sedikit lebih lambat.
Double-post klasik: penulisan ke ERP diletakkan sebelum interrupt() di node yang sama. Run pertama membuat draft lalu berhenti; persetujuan me-resume node dari atas dan membuat draft lagi. Letakkan penulisan di node terpisah setelah persetujuan, atau buat idempotent, dan jangan pernah membungkus interrupt() dengan try/except kosong, karena mekanismenya bekerja dengan melempar exception secara internal.
Persetujuan manusia di aplikasi web, bukan di terminal
Langkah persetujuan adalah titik di mana default kedua dokumentasi paling berbeda. human_feedback milik CrewAI memblokir input console kecuali Anda memberikan provider. interrupt milik LangGraph tidak pernah memblokir: ia menyimpan checkpoint dan mengembalikan payload ke pemanggil, sehingga jeda dan jawaban secara alami menjadi dua request terpisah.
# CrewAI: the default @human_feedback calls input() and blocks a worker.
# Wrong for a web app: the request thread waits on a terminal nobody sees.
# Right: pass provider=... to @human_feedback. The provider raises
# HumanFeedbackPending, kickoff() returns it, and the flow state is
# persisted automatically. Your approval endpoint later calls:
await flow.resume_async(feedback_text) # resume() from inside a running
# event loop raises RuntimeError
# LangGraph: the interrupt payload must be JSON-serialisable, because it
# is stored by the checkpointer and handed to whoever resumes the thread.
graph.invoke(Command(resume="approve"), {"configurable": {"thread_id": tid}})Pada praktiknya keduanya berakhir di arsitektur yang sama: run berhenti, record persetujuan masuk ke antrean atau pesan chat, lalu webhook me-resume run dengan keputusannya. LangGraph sampai ke sana tanpa kode tambahan. CrewAI sampai ke sana setelah Anda mengimplementasikan provider, dan sebagai gantinya balasan teks bebas dari reviewer bisa diklasifikasikan menjadi outcome oleh model.
Simpan payload jeda di tabel approval milik Anda sendiri, selain di state framework. Approver, auditor dan tim finance akan bertanya invoice mana yang sedang menunggu dan kenapa, dan query itu sebaiknya mengenai tabel biasa, bukan blob checkpoint.
Observability dan platform managed
Setiap framework punya platform komersial dari perusahaan yang sama. LangGraph mengirim tracing ke LangSmith, dan LangSmith Deployment menjalankan graph sebagai layanan managed dengan persistence dan task queue. CrewAI punya tracing bawaan yang melapor ke CrewAI AMP, platform manajemen agent-nya, yang juga bisa meng-host crew dan flow. Tidak satu pun framework mewajibkan platformnya, tetapi tooling visual masing-masing mengasumsikannya.
Bagi tim yang sudah menjalankan infrastrukturnya sendiri, pertanyaan yang lebih penting adalah apa yang bisa dilihat tanpa platform. get_state dan get_state_history di LangGraph memungkinkan Anda memeriksa setiap checkpoint sebuah thread dari database Anda sendiri. CrewAI menyediakan flow.plot() untuk strukturnya dan flow.usage_metrics untuk jumlah token di semua panggilan LLM dalam satu run, berguna untuk menghitung biaya per invoice.
Mana yang dipilih untuk agent produksi
Periksa poin berikut secara berurutan dan berhenti di poin pertama yang menjawab.
- Kalau sebagian run harus disetujui manusia, dan jawabannya bisa datang setelah restart, mulai dengan LangGraph: jeda, checkpoint dan resume adalah API intinya, bukan tambahan.
- Kalau pekerjaannya eksploratif, dengan beberapa agent yang meriset, menulis draft dan saling mereview, mulai dengan crew CrewAI dan tambahkan Flow hanya di bagian yang urutannya penting.
- Kalau Anda perlu memutar ulang run yang gagal dari langkah sebelumnya untuk debugging, riwayat checkpoint LangGraph adalah alat yang lebih kuat.
- Kalau tim baru mengenal agent dan butuh sesuatu yang jalan minggu ini, jalur CrewAI yang lebih pendek menuju hasil pertama adalah alasan yang wajar, asalkan ada yang bertanggung jawab atas persistence dan provider persetujuan sebelum agent menyentuh ERP.
Tidak ada pilihan yang menjebak. LangGraph 1.0 berkomitmen tidak ada breaking change sampai 2.0, dan CrewAI menerbitkan dokumentasi berversi untuk setiap rilis, jadi apa pun yang Anda pilih, pin versinya dan baca changelog sebelum upgrade.
Pertanyaan penentunya bukan framework mana yang punya lebih banyak agent atau lebih banyak star. Pertanyaannya adalah apa yang terjadi saat sebuah run berhenti di tengah jalan lalu dilanjutkan nanti di proses lain. LangGraph menjawabnya dengan checkpoint eksplisit dan node yang diputar ulang dari atas; CrewAI menjawabnya dengan state Flow yang dipersist dan provider feedback yang Anda sediakan. Rancang side effect untuk jawaban itu dulu, baru prompt-nya.

