1 
2AI 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.
3 
4Empat 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.
5 
6## Sekilas
7 
8| Aspek | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Oleh** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Arsitektur** | Berbasis graph | Berbasis role | Berbasis handoff | Autonomous loop |
12| **Filosofi** | Kontrol maksimum | Kolaborasi tim | Abstraksi minimal | Beri agent sebuah komputer |
13| **Bahasa** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Dukungan model** | Apa saja (OpenAI, Claude, lokal) | Apa saja | Apa saja (meski namanya) | Hanya Claude |
15| **GitHub stars** | ~29k | ~40k | ~21k | ~6k |
16| **Terbaik untuk** | Workflow stateful kompleks | Spesialisasi multi-agent | Routing dan triage | Coding dan tugas berat file |
17 
18## LangGraph: Pembangun Graph
19 
20LangGraph 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.
21 
22Ini adalah framework yang paling eksplisit dan terkontrol  -  Anda mengatur setiap langkah sendiri.
23 
24```mermaid
25graph LR
26    Start --> Router[Router Node]
27    Router -->|needs research| Research[Research Node]
28    Router -->|needs code| Code[Code Node]
29    Research --> Synthesize[Synthesize Node]
30    Code --> Synthesize
31    Synthesize --> End
32```
33 
34### Konsep Inti
35 
36- **StateGraph**: definisi graph dengan state bertipe
37- **Nodes**: fungsi Python yang mengubah state
38- **Edges**: koneksi antar node, bisa bersyarat
39- **Checkpointing**: persistence bawaan untuk workflow yang berjalan lama
40 
41### Contoh Kode
42 
43```python
44from langgraph.graph import StateGraph, MessagesState, START, END
45from langchain_openai import ChatOpenAI
46 
47llm = ChatOpenAI(model="gpt-4o")
48 
49def call_agent(state: MessagesState):
50    response = llm.invoke(state["messages"])
51    return {"messages": [response]}
52 
53def should_continue(state: MessagesState):
54    last = state["messages"][-1]
55    if last.tool_calls:
56        return "tools"
57    return END
58 
59def call_tools(state: MessagesState):
60    # Execute tool calls and return results
61    results = []
62    for tool_call in state["messages"][-1].tool_calls:
63        result = execute_tool(tool_call)
64        results.append(result)
65    return {"messages": results}
66 
67graph = StateGraph(MessagesState)
68graph.add_node("agent", call_agent)
69graph.add_node("tools", call_tools)
70graph.add_edge(START, "agent")
71graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
72graph.add_edge("tools", "agent")
73 
74app = graph.compile()
75result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
76```
77 
78### Kekuatan
79 
80- Kontrol halus atas setiap langkah dan transisi
81- Checkpointing bawaan dan human-in-the-loop
82- Paritas TypeScript penuh
83- Bekerja dengan penyedia LLM apa pun
84- Terbaik untuk workflow kompleks dengan conditional branching dan loops
85 
86### Kelemahan
87 
88- Kurva pembelajaran curam  -  Anda perlu memahami konsep teori graph
89- Bertele-tele untuk use case sederhana  -  agent dasar memerlukan lebih banyak boilerplate daripada framework lain
90- Men-debug graph flow bisa menantang tanpa LangSmith
91 
92### Harga
93 
94Open-source (MIT). LangSmith (platform observability terkelola) memiliki tier berbayar untuk production monitoring.
95 
96## CrewAI: Perakit Tim
97 
98CrewAI 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).
99 
100Anggap saja seperti merekrut tim di mana setiap anggota memiliki jabatan dan keahlian spesifik.
101 
102```mermaid
103graph TD
104    Crew[Crew Manager] --> R[Researcher\nRole: Find data\nTools: WebSearch]
105    Crew --> W[Writer\nRole: Write content\nTools: FileWrite]
106    Crew --> E[Editor\nRole: Review quality\nTools: FileRead]
107    R --> Task1[Research Task]
108    W --> Task2[Writing Task]
109    E --> Task3[Review Task]
110    Task1 --> Task2 --> Task3
111```
112 
113### Konsep Inti
114 
115- **Agent**: persona dengan role, goal, backstory, dan tool
116- **Task**: penugasan dengan deskripsi, output yang diharapkan, dan agent yang ditugaskan
117- **Crew**: sekelompok agent yang bekerja bersama
118- **Process**: strategi eksekusi (sequential, hierarchical, consensual)
119- **Flow**: lapisan orkestrasi berbasis event untuk menghubungkan beberapa crew
120 
121### Contoh Kode
122 
123```python
124from crewai import Agent, Task, Crew, Process
125 
126researcher = Agent(
127    role="Senior Research Analyst",
128    goal="Find comprehensive data about the given topic",
129    backstory="You have 10 years of experience in technology research. "
130              "You are thorough and always verify facts from multiple sources.",
131    tools=[web_search_tool],
132    verbose=True,
133)
134 
135writer = Agent(
136    role="Technical Writer",
137    goal="Create clear, engaging technical content",
138    backstory="You write for a developer audience. "
139              "Your articles are practical and include code examples.",
140    tools=[file_tool],
141    verbose=True,
142)
143 
144research_task = Task(
145    description="Research the latest developments in WebAssembly in 2026. "
146                "Focus on WASI, Component Model, and production use cases.",
147    expected_output="A structured research document with key findings and sources.",
148    agent=researcher,
149)
150 
151writing_task = Task(
152    description="Write a blog post based on the research. "
153                "Include code examples and Mermaid diagrams.",
154    expected_output="A complete blog post in Markdown format.",
155    agent=writer,
156    context=[research_task],  # Writer receives researcher's output
157)
158 
159crew = Crew(
160    agents=[researcher, writer],
161    tasks=[research_task, writing_task],
162    process=Process.sequential,
163    verbose=True,
164)
165 
166result = crew.kickoff()
167print(result.raw)
168```
169 
170### Kekuatan
171 
172- Abstraksi berbasis role yang intuitif  -  mudah dipikirkan
173- 100+ integrasi tool bawaan
174- Memory bersama antar agent (short-term, long-term, entity)
175- Komunitas terbesar (~40k GitHub stars)
176- Hierarchical process dengan agent "manager" yang mendelegasikan dan memvalidasi
177 
178### Kelemahan
179 
180- Kurang kontrol halus dibanding LangGraph  -  Anda mendefinisikan role, bukan jalur eksekusi yang tepat
181- Hierarchical process bisa tidak dapat diprediksi ketika agent tidak setuju
182- Men-debug percakapan multi-agent lebih sulit daripada single-agent flow
183 
184### Harga
185 
186Core open-source (gratis). CrewAI Platform: $99/bulan (Teams) hingga $120k/tahun (Enterprise). Harga berdasarkan live crew dan eksekusi bulanan.
187 
188## OpenAI Agents SDK: Sang Router
189 
190OpenAI 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.
191 
192```mermaid
193graph LR
194    User --> Triage[Triage Agent]
195    Triage -->|billing question| Billing[Billing Agent]
196    Triage -->|refund request| Refund[Refund Agent]
197    Triage -->|technical issue| Support[Support Agent]
198    Billing --> Response[Response]
199    Refund --> Response
200    Support --> Response
201```
202 
203### Konsep Inti
204 
205- **Agent**: model + instruksi + tool + handoff
206- **Handoff**: transfer ke agent lain (dimodelkan sebagai tool yang bisa dipanggil LLM)
207- **Guardrail**: validasi input/output yang berjalan paralel dengan agent
208- **Runner**: menjalankan agent loop
209- **Tracing**: observability bawaan untuk semua panggilan LLM, pemanggilan tool, dan handoff
210 
211### Contoh Kode
212 
213```python
214from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
215from pydantic import BaseModel
216 
217class SafetyCheck(BaseModel):
218    is_safe: bool
219    reason: str
220 
221async def content_safety(ctx, agent, input_text):
222    result = await Runner.run(
223        Agent(name="Safety", instructions="Check if input is safe. No PII."),
224        input_text,
225        context=ctx,
226    )
227    output = SafetyCheck.model_validate_json(result.final_output)
228    return GuardrailFunctionOutput(
229        output_info=output, tripwire_triggered=not output.is_safe
230    )
231 
232billing_agent = Agent(
233    name="Billing Agent",
234    instructions="You handle billing inquiries. Be precise with numbers.",
235    tools=[lookup_invoice, process_payment],
236)
237 
238refund_agent = Agent(
239    name="Refund Agent",
240    instructions="You process refund requests. Always verify the order first.",
241    tools=[lookup_order, issue_refund],
242)
243 
244triage_agent = Agent(
245    name="Triage Agent",
246    instructions="Route the customer to the right specialist. "
247                 "Ask clarifying questions if needed.",
248    handoffs=[billing_agent, refund_agent],
249    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
250)
251 
252result = await Runner.run(triage_agent, "I need a refund for order #4521")
253print(result.final_output)
254# The triage agent routes to refund_agent, which processes the refund
255```
256 
257### Kekuatan
258 
259- Pola handoff yang bersih  -  alami untuk workflow routing/triage
260- Guardrail berjalan paralel dengan eksekusi (fail-fast, tidak memblokir)
261- Dashboard tracing bawaan untuk debugging
262- Meskipun namanya, mendukung model non-OpenAI
263- Abstraksi minimal  -  mudah dipahami dan diperluas
264 
265### Kelemahan
266 
267- Manajemen state kurang matang dibanding LangGraph
268- Tidak ada persistence atau checkpointing bawaan
269- Ekosistem tool pihak ketiga lebih kecil
270- Desain yang berpusat pada handoff mungkin tidak cocok untuk setiap arsitektur
271 
272### Harga
273 
274Open-source (MIT). Anda membayar per-token untuk model apa pun yang Anda gunakan.
275 
276## Claude Agent SDK: Sang Developer
277 
278Claude 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.
279 
280```mermaid
281graph TD
282    Prompt[User Prompt] --> Loop[Autonomous Agent Loop]
283    Loop --> Reason[Reason about next step]
284    Reason --> Act[Execute tool]
285    Act --> Verify[Check result]
286    Verify -->|not done| Loop
287    Verify -->|done| Output[Final output]
288```
289 
290### Konsep Inti
291 
292- **query()**: entry point utama yang memulai agent loop
293- **Built-in tools**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Custom tools via MCP**: mendefinisikan tool sebagai in-process MCP server
295- **Sub-agents**: agent khusus yang bisa didelegasikan oleh parent
296- **Sessions**: mempertahankan konteks di beberapa interaksi
297 
298### Contoh Kode
299 
300```typescript
301import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
302import { z } from "zod";
303 
304const searchDocs = tool(
305  "search_docs",
306  "Search the internal documentation for relevant information",
307  { query: z.string().describe("Search query") },
308  async ({ query }) => {
309    const results = await vectorStore.similaritySearch(query, 5);
310    return {
311      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
312    };
313  }
314);
315 
316const docsServer = createSdkMcpServer({
317  name: "docs",
318  version: "1.0.0",
319  tools: [searchDocs],
320});
321 
322for await (const message of query({
323  prompt: "Find how authentication works in our system and write a summary",
324  options: {
325    mcpServers: { docs: docsServer },
326    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
327  },
328})) {
329  if (message.type === "result" && message.subtype === "success") {
330    console.log(message.result);
331  }
332}
333```
334 
335### Kekuatan
336 
337- Integrasi MCP kelas satu  -  terhubung ke ekosistem MCP server apa pun
338- Tool bawaan untuk operasi file, terminal, dan akses web
339- Pemadatan konteks otomatis untuk codebase besar
340- Paralelisme sub-agent untuk tugas kompleks
341- Engine yang sama dengan Claude Code  -  teruji di workflow development nyata
342 
343### Kelemahan
344 
345- Hanya model Claude  -  tidak ada dukungan multi-provider
346- Framework lebih baru dengan komunitas lebih kecil
347- Memerlukan runtime Node.js bahkan untuk Python SDK
348- Kurang kontrol workflow eksplisit dibanding LangGraph
349 
350### Harga
351 
352Open-source. Tarif token Claude API standar. Managed Agents (versi hosted): $0.08 per session-hour sebagai tambahan biaya token.
353 
354## Kapan Memilih yang Mana
355 
356```mermaid
357graph TD
358    Start{What's your priority?}
359    Start -->|Full control over workflow| LG[LangGraph]
360    Start -->|Multi-agent collaboration| CA[CrewAI]
361    Start -->|Routing and triage| OA[OpenAI Agents SDK]
362    Start -->|Coding and file automation| CS[Claude Agent SDK]
363 
364    LG --> LGU[Complex stateful workflows\nConditional branching\nHuman-in-the-loop]
365    CA --> CAU[Team of specialized agents\nResearch + writing pipelines\nContent generation]
366    OA --> OAU[Customer service routing\nMulti-step handoffs\nInput validation]
367    CS --> CSU[Code generation and review\nFile-heavy automation\nMCP tool ecosystem]
368```
369 
370### Pilih LangGraph jika:
371- Anda membutuhkan kontrol presisi atas setiap langkah workflow
372- Use case Anda melibatkan logika kondisional kompleks dan loop
373- Anda ingin persistence bawaan dan checkpoint human-in-the-loop
374- Anda perlu menggunakan beberapa penyedia LLM dalam workflow yang sama
375 
376### Pilih CrewAI jika:
377- Anda ingin abstraksi berbasis role yang intuitif
378- Tugas Anda melibatkan beberapa agent dengan spesialisasi berbeda
379- Anda membutuhkan agent untuk berkolaborasi dan meneruskan konteks satu sama lain
380- Anda menghargai komunitas terbesar dan integrasi bawaan terbanyak
381 
382### Pilih OpenAI Agents SDK jika:
383- Pola utama Anda adalah merutekan percakapan ke spesialis
384- Anda butuh guardrail yang memvalidasi input/output secara paralel
385- Anda ingin abstraksi sesederhana mungkin dengan boilerplate minimal
386- Tracing dan observability bawaan penting
387 
388### Pilih Claude Agent SDK jika:
389- Agent Anda perlu membaca, menulis, dan mengeksekusi kode
390- Anda ingin integrasi MCP server kelas satu
391- Anda membutuhkan agent autonomous yang beriterasi dan mengoreksi diri
392- Anda sudah menggunakan Claude dan ingin integrasi terdalam
393 
394## Bisakah Anda Menggabungkan Framework?
395 
396Ya. Pola umum adalah menggunakan satu framework untuk orkestrasi dan lainnya untuk agent individual:
397 
398- **LangGraph** untuk graph workflow keseluruhan
399- **CrewAI** untuk node spesifik yang membutuhkan kolaborasi multi-agent
400- **Claude Agent SDK** untuk sub-tugas terkait coding via MCP
401- **OpenAI Agents SDK** untuk triage dan routing yang menghadap pelanggan
402 
403Framework tidak saling eksklusif. Gunakan apa yang sesuai untuk setiap bagian sistem Anda.
404 
405## Kesimpulan
406 
407Setiap framework membuat taruhan yang jelas:
408 
409- **LangGraph** dioptimalkan untuk kontrol  -  Anda yang memutuskan setiap transisi
410- **CrewAI** dioptimalkan untuk kolaborasi  -  agent bekerja sebagai tim
411- **OpenAI Agents SDK** dioptimalkan untuk kesederhanaan  -  abstraksi minimal, handoff yang bersih
412- **Claude Agent SDK** dioptimalkan untuk otonomi  -  beri tool dan biarkan bekerja
413 
414Pilihan 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.
415