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~