1 
2AI 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.
3 
4Empat 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.
5 
6## Sepintas Lalu
7 
8| Aspek | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Oleh** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Seni bina** | Berasaskan graph | Berasaskan role | Berasaskan handoff | Autonomous loop |
12| **Falsafah** | Kawalan maksimum | Kerjasama pasukan | Abstraksi minimum | Beri agent sebuah komputer |
13| **Bahasa** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Sokongan model** | Mana-mana (OpenAI, Claude, tempatan) | Mana-mana | Mana-mana (walaupun namanya) | Claude sahaja |
15| **GitHub stars** | ~29k | ~40k | ~21k | ~6k |
16| **Terbaik untuk** | Workflow stateful kompleks | Pengkhususan multi-agent | Routing dan triage | Coding dan tugasan berat fail |
17 
18## LangGraph: Pembina Graph
19 
20LangGraph 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.
21 
22Ini adalah framework yang paling eksplisit dan boleh dikawal  -  anda menyambung 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 Utama
35 
36- **StateGraph**: definisi graph dengan state bertaip
37- **Nodes**: fungsi Python yang mengubah state
38- **Edges**: sambungan antara nodes, boleh bersyarat
39- **Checkpointing**: persistence terbina dalam untuk workflow jangka panjang
40 
41### Contoh Kod
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- Kawalan halus ke atas setiap langkah dan transisi
81- Checkpointing terbina dalam dan human-in-the-loop
82- Pariti TypeScript penuh
83- Berfungsi dengan mana-mana penyedia LLM
84- Terbaik untuk workflow kompleks dengan conditional branching dan loops
85 
86### Kelemahan
87 
88- Keluk pembelajaran curam  -  anda perlu memahami konsep teori graph
89- Meleret untuk use case mudah  -  agent asas memerlukan lebih banyak boilerplate daripada framework lain
90- Nyahpepijat aliran graph boleh mencabar tanpa LangSmith
91 
92### Harga
93 
94Open-source (MIT). LangSmith (platform observability terurus) mempunyai tier berbayar untuk pemantauan production.
95 
96## CrewAI: Pemasang Pasukan
97 
98CrewAI 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).
99 
100Fikirkannya seperti mengupah pasukan di mana setiap ahli mempunyai jawatan dan kepakaran tertentu.
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 Utama
114 
115- **Agent**: persona dengan role, goal, backstory, dan tools
116- **Task**: tugasan dengan penerangan, output yang dijangka, dan agent yang ditugaskan
117- **Crew**: sekumpulan ejen yang bekerjasama
118- **Process**: strategi pelaksanaan (sequential, hierarchical, consensual)
119- **Flow**: lapisan orkestra berasaskan peristiwa untuk menghubungkan beberapa crew
120 
121### Contoh Kod
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 berasaskan role yang intuitif  -  mudah untuk difikirkan
173- 100+ integrasi tool terbina dalam
174- Memory dikongsi antara ejen (jangka pendek, jangka panjang, entiti)
175- Komuniti terbesar (~40k GitHub stars)
176- Hierarchical process dengan agent "manager" yang mewakilkan dan mengesahkan
177 
178### Kelemahan
179 
180- Kurang kawalan halus berbanding LangGraph  -  anda mentakrifkan roles, bukan laluan pelaksanaan yang tepat
181- Hierarchical process boleh menjadi tidak dapat diramal apabila ejen tidak bersetuju
182- Nyahpepijat perbualan multi-agent lebih sukar daripada aliran single-agent
183 
184### Harga
185 
186Teras open-source (percuma). CrewAI Platform: $99/bulan (Teams) sehingga $120k/tahun (Enterprise). Harga berdasarkan live crew dan pelaksanaan bulanan.
187 
188## OpenAI Agents SDK: Sang Router
189 
190OpenAI 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.
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 Utama
204 
205- **Agent**: model + arahan + tools + handoffs
206- **Handoff**: pemindahan kepada ejen lain (dimodelkan sebagai tool yang boleh dipanggil LLM)
207- **Guardrail**: pengesahan input/output yang berjalan selari dengan agent
208- **Runner**: melaksanakan agent loop
209- **Tracing**: observability terbina dalam untuk semua panggilan LLM, pemanggilan tool, dan handoffs
210 
211### Contoh Kod
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- Corak handoff yang bersih  -  semula jadi untuk workflow routing/triage
260- Guardrails berjalan selari dengan pelaksanaan (fail-fast, bukan menyekat)
261- Dashboard tracing terbina dalam untuk debugging
262- Walaupun namanya, menyokong model bukan OpenAI
263- Abstraksi minimum  -  mudah difahami dan dikembangkan
264 
265### Kelemahan
266 
267- Pengurusan state kurang matang berbanding LangGraph
268- Tiada persistence atau checkpointing terbina dalam
269- Ekosistem tool pihak ketiga lebih kecil
270- Reka bentuk berpusatkan handoff mungkin tidak sesuai untuk setiap seni bina
271 
272### Harga
273 
274Open-source (MIT). Anda membayar per-token untuk mana-mana model yang anda gunakan.
275 
276## Claude Agent SDK: Sang Developer
277 
278Claude 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.
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 Utama
291 
292- **query()**: titik masuk utama yang memulakan agent loop
293- **Built-in tools**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Custom tools via MCP**: takrifkan tools sebagai MCP server dalam proses
295- **Sub-agents**: ejen khusus yang boleh diwakilkan oleh parent
296- **Sessions**: mengekalkan konteks merentasi pelbagai interaksi
297 
298### Contoh Kod
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 pertama  -  sambung ke mana-mana ekosistem MCP server
338- Tools terbina dalam untuk operasi fail, terminal, dan akses web
339- Pemadatan konteks automatik untuk codebase besar
340- Keselarian sub-agent untuk tugas kompleks
341- Enjin yang sama dengan Claude Code  -  teruji pertempuran pada workflow development sebenar
342 
343### Kelemahan
344 
345- Model Claude sahaja  -  tiada sokongan multi-provider
346- Framework lebih baharu dengan komuniti lebih kecil
347- Memerlukan Node.js runtime walaupun untuk Python SDK
348- Kurang kawalan workflow eksplisit berbanding LangGraph
349 
350### Harga
351 
352Open-source. Kadar token Claude API standard. Managed Agents (versi dihoskan): $0.08 setiap session-hour sebagai tambahan kepada kos token.
353 
354## Bila 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 memerlukan kawalan tepat ke atas setiap langkah workflow
372- Use case anda melibatkan logik bersyarat kompleks dan loops
373- Anda mahukan persistence terbina dalam dan human-in-the-loop checkpoint
374- Anda perlu menggunakan beberapa penyedia LLM dalam workflow yang sama
375 
376### Pilih CrewAI jika:
377- Anda mahukan abstraksi berasaskan role yang intuitif
378- Tugas anda melibatkan beberapa ejen dengan kepakaran berbeza
379- Anda memerlukan ejen untuk bekerjasama dan menghantar konteks antara satu sama lain
380- Anda menghargai komuniti terbesar dan integrasi terbina dalam yang paling banyak
381 
382### Pilih OpenAI Agents SDK jika:
383- Corak utama anda ialah menghalakan perbualan kepada pakar
384- Anda memerlukan guardrails yang mengesahkan input/output secara selari
385- Anda mahukan abstraksi paling mudah yang mungkin dengan boilerplate minimum
386- Tracing dan observability terbina dalam adalah penting
387 
388### Pilih Claude Agent SDK jika:
389- Ejen anda perlu membaca, menulis, dan melaksanakan kod
390- Anda mahukan integrasi MCP server kelas pertama
391- Anda memerlukan ejen autonomous yang beriterasi dan membetulkan diri
392- Anda sudah menggunakan Claude dan mahukan integrasi terdalam
393 
394## Bolehkah Anda Menggabungkan Framework?
395 
396Ya. Corak biasa ialah menggunakan satu framework untuk orkestra dan satu lagi untuk ejen individu:
397 
398- **LangGraph** untuk graph workflow keseluruhan
399- **CrewAI** untuk node tertentu yang memerlukan kerjasama multi-agent
400- **Claude Agent SDK** untuk sub-tugas berkaitan coding melalui MCP
401- **OpenAI Agents SDK** untuk triage dan routing yang menghadap pelanggan
402 
403Framework tidak saling eksklusif. Gunakan apa yang sesuai untuk setiap bahagian sistem anda.
404 
405## Kesimpulan
406 
407Setiap framework membuat pertaruhan yang jelas:
408 
409- **LangGraph** dioptimumkan untuk kawalan  -  anda memutuskan setiap transisi
410- **CrewAI** dioptimumkan untuk kerjasama  -  ejen bekerja sebagai pasukan
411- **OpenAI Agents SDK** dioptimumkan untuk kesederhanaan  -  abstraksi minimum, handoffs bersih
412- **Claude Agent SDK** dioptimumkan untuk autonomi  -  beri ia tools dan biarkan ia bekerja
413 
414Pilihan 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.
415