1 
2Ang mga AI agent ay lumipat na mula sa research demos patungo sa production systems. Higit sa 60% ng enterprise AI applications ang inaasahang maglalaman ng mga agentic component sa 2026. Ngunit ang pagbuo ng mga agent mula sa simula  -  pagmamanage ng tool loops, state, memory, error handling, at multi-agent coordination  -  ay komplikado. Dito pumapasok ang mga framework.
3 
4Apat na framework ang nangingibabaw sa 2026: **LangGraph**, **CrewAI**, **OpenAI Agents SDK**, at **Claude Agent SDK**. Bawat isa ay may iba't ibang pangunahing diskarte sa parehong problema: pagbibigay sa mga LLM ng kakayahang mag-reason, magplano, gumamit ng tool, at magtulungan.
5 
6## Isang Sulyap
7 
8| Aspeto | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Ng** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Arkitektura** | Graph-based | Role-based | Handoff-based | Autonomous loop |
12| **Pilosopiya** | Maximum control | Team collaboration | Minimal abstraction | Bigyan ang agent ng computer |
13| **Mga wika** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Model support** | Kahit ano (OpenAI, Claude, local) | Kahit ano | Kahit ano (sa kabila ng pangalan) | Claude lamang |
15| **GitHub stars** | ~29k | ~40k | ~21k | ~6k |
16| **Pinakamainam para sa** | Komplikadong stateful workflows | Multi-agent specialization | Routing at triage | Coding at file-heavy na tasks |
17 
18## LangGraph: Ang Graph Builder
19 
20Minomodelo ng LangGraph ang agent workflows bilang **directed cyclic graphs**. Tinutukoy mo ang mga node (mga function na gumagawa ng trabaho) at mga edge (mga transition sa pagitan nila, opsyonal na conditional). Ang state ay dumadaloy sa graph at tumatagal sa pamamagitan ng checkpointing.
21 
22Ito ang pinaka-eksplisito at pinakakontroladong framework  -  ikaw mismo ang nagwi-wire ng bawat hakbang.
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### Mga Pangunahing Konsepto
35 
36- **StateGraph**: ang graph definition na may typed state
37- **Nodes**: Python functions na nagba-transform ng state
38- **Edges**: mga koneksyon sa pagitan ng mga node, maaaring conditional
39- **Checkpointing**: built-in persistence para sa long-running workflows
40 
41### Halimbawa ng Code
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### Mga Kalakasan
79 
80- Fine-grained control sa bawat hakbang at transition
81- Built-in checkpointing at human-in-the-loop
82- Buong TypeScript parity
83- Gumagana sa anumang LLM provider
84- Pinakamainam para sa komplikadong workflows na may conditional branching at loops
85 
86### Mga Kahinaan
87 
88- Matarik na learning curve  -  kailangan mong unawain ang mga konsepto ng graph theory
89- Verbose para sa simpleng use cases  -  ang basic agent ay nangangailangan ng mas maraming boilerplate kumpara sa ibang frameworks
90- Ang pag-debug ng graph flows ay maaaring maging mahirap nang walang LangSmith
91 
92### Presyo
93 
94Open-source (MIT). Ang LangSmith (managed observability platform) ay may mga bayad na tier para sa production monitoring.
95 
96## CrewAI: Ang Team Assembler
97 
98Gumagamit ang CrewAI ng pantaong metapora: bubuo ka ng isang **crew** ng mga espesyalisadong agent, bawat isa ay may **role**, **goal**, at **backstory**. Nagtutulungan ang mga agent sa mga **task** gamit ang mga **tool**, na pinag-uugnay ng isang **process** (sequential, hierarchical, o consensual).
99 
100Isipin ito bilang pagkuha ng koponan kung saan ang bawat miyembro ay may tiyak na titulo sa trabaho at espesyalisasyon.
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### Mga Pangunahing Konsepto
114 
115- **Agent**: isang persona na may role, goal, backstory, at mga tool
116- **Task**: isang takdang-aralin na may deskripsyon, inaasahang output, at itinalagang agent
117- **Crew**: isang grupo ng mga agent na nagtutulungan
118- **Process**: execution strategy (sequential, hierarchical, consensual)
119- **Flow**: event-driven orchestration layer para sa pagkonekta ng maraming crew
120 
121### Halimbawa ng Code
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### Mga Kalakasan
171 
172- Madaling maintindihan na role-based abstraction  -  madaling pag-isipan
173- 100+ na built-in tool integrations
174- Shared memory sa mga agent (short-term, long-term, entity)
175- Pinakamalaking komunidad (~40k GitHub stars)
176- Hierarchical process na may "manager" agent na nagde-delegate at nagva-validate
177 
178### Mga Kahinaan
179 
180- Mas kaunting fine-grained control kaysa sa LangGraph  -  nagtatakda ka ng mga role, hindi tiyak na execution paths
181- Ang hierarchical process ay maaaring maging di-mahuhulaan kapag hindi sumasang-ayon ang mga agent
182- Ang pag-debug ng multi-agent conversations ay mas mahirap kaysa sa single-agent flows
183 
184### Presyo
185 
186Libreng open-source core. CrewAI Platform: $99/buwan (Teams) hanggang $120k/taon (Enterprise). Ang presyo ay batay sa live crews at buwanang executions.
187 
188## OpenAI Agents SDK: Ang Router
189 
190Ang OpenAI Agents SDK (espiritual na kahalili ng Swarm) ay nakatuon sa **handoffs**  -  mga agent na naglilipat ng mga pag-uusap sa iba pang mga espesyalisadong agent. Ito ang pinakaminimal na framework: mga agent, tool, handoff, at guardrail. Iyon lang.
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### Mga Pangunahing Konsepto
204 
205- **Agent**: model + instructions + tools + handoffs
206- **Handoff**: isang paglipat sa ibang agent (modelo bilang tool na maaaring tawagin ng LLM)
207- **Guardrail**: input/output validation na tumatakbo nang parallel sa agent
208- **Runner**: nag-e-execute ng agent loop
209- **Tracing**: built-in observability para sa lahat ng LLM calls, tool invocations, at handoffs
210 
211### Halimbawa ng Code
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### Mga Kalakasan
258 
259- Malinis na handoff pattern  -  likas para sa routing/triage workflows
260- Ang mga guardrail ay tumatakbo nang parallel sa execution (fail-fast, hindi blocking)
261- Built-in tracing dashboard para sa debugging
262- Sa kabila ng pangalan, sumusuporta ito sa mga non-OpenAI model
263- Minimal abstraction  -  madaling maunawaan at palawakin
264 
265### Mga Kahinaan
266 
267- Hindi kasing-matured ang state management kumpara sa LangGraph
268- Walang built-in persistence o checkpointing
269- Mas maliit ang ekosistema ng third-party tools
270- Ang handoff-centric design ay maaaring hindi angkop sa lahat ng arkitektura
271 
272### Presyo
273 
274Open-source (MIT). Nagbabayad ka kada-token para sa anumang modelong ginagamit mo.
275 
276## Claude Agent SDK: Ang Developer
277 
278Ang Claude Agent SDK ay may kakaibang diskarte: sa halip na magtakda ng mga workflow o role, binibigyan mo ang agent ng isang **set ng mga tool at hinahayaan itong mag-isip kung paano tapusin ang gawain**. Ginagamit nito ang parehong autonomous loop na nagpapatakbo sa Claude Code  -  basahin, kumilos, i-verify, ulitin.
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### Mga Pangunahing Konsepto
291 
292- **query()**: ang pangunahing entry point na nagsisimula sa agent loop
293- **Built-in tools**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Custom tools via MCP**: magtakda ng mga tool bilang in-process MCP servers
295- **Sub-agents**: mga espesyalisadong agent na maaaring i-delegate ng parent
296- **Sessions**: mapanatili ang konteksto sa maraming interaksyon
297 
298### Halimbawa ng Code
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### Mga Kalakasan
336 
337- First-class MCP integration  -  kumonekta sa anumang MCP server ecosystem
338- Built-in tools para sa file operations, terminal, at web access
339- Awtomatikong context compaction para sa malalaking codebase
340- Sub-agent parallelism para sa komplikadong tasks
341- Parehong engine ng Claude Code  -  battle-tested sa totoong development workflows
342 
343### Mga Kahinaan
344 
345- Mga modelong Claude lamang  -  walang multi-provider support
346- Mas bagong framework na may mas maliit na komunidad
347- Nangangailangan ng Node.js runtime kahit para sa Python SDK
348- Mas kaunting eksplisitong workflow control kumpara sa LangGraph
349 
350### Presyo
351 
352Open-source. Standard Claude API token rates. Managed Agents (hosted version): $0.08 kada session-hour bukod pa sa token costs.
353 
354## Kailan Piliin Kung Alin
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### Piliin ang LangGraph kung:
371- Kailangan mo ng tiyak na kontrol sa bawat hakbang ng workflow
372- Ang iyong use case ay may kinalaman sa komplikadong conditional logic at loops
373- Gusto mo ng built-in persistence at human-in-the-loop checkpoints
374- Kailangan mong gumamit ng maraming LLM providers sa parehong workflow
375 
376### Piliin ang CrewAI kung:
377- Gusto mo ng madaling maunawaan, role-based na abstraction
378- Ang iyong gawain ay may kinalaman sa maraming agent na may iba't ibang espesyalisasyon
379- Kailangan mo ng mga agent na magtulungan at magpasa ng konteksto sa isa't isa
380- Pinahahalagahan mo ang pinakamalaking komunidad at pinakamaraming built-in integrations
381 
382### Piliin ang OpenAI Agents SDK kung:
383- Ang iyong pangunahing pattern ay pag-ruta ng mga pag-uusap sa mga espesyalista
384- Kailangan mo ng mga guardrail na nagva-validate ng input/output nang parallel
385- Gusto mo ng pinakasimpleng posibleng abstraction na may minimal na boilerplate
386- Mahalaga ang built-in tracing at observability
387 
388### Piliin ang Claude Agent SDK kung:
389- Ang iyong mga agent ay kailangang magbasa, magsulat, at mag-execute ng code
390- Gusto mo ng first-class MCP server integration
391- Kailangan mo ng autonomous agents na nag-i-iterate at nagsasaayos sa sarili
392- Gumagamit ka na ng Claude at gusto mo ng pinakamalalim na integrasyon
393 
394## Maaari Mo Bang Pagsamahin ang mga Framework?
395 
396Oo. Isang karaniwang pattern ay ang paggamit ng isang framework para sa orkestrasyon at ibang framework para sa mga indibidwal na agent:
397 
398- **LangGraph** para sa kabuuang workflow graph
399- **CrewAI** para sa isang partikular na node na nangangailangan ng multi-agent collaboration
400- **Claude Agent SDK** para sa mga coding-related sub-task sa pamamagitan ng MCP
401- **OpenAI Agents SDK** para sa customer-facing triage at routing
402 
403Ang mga framework ay hindi mutually exclusive. Gamitin ang angkop sa bawat bahagi ng iyong sistema.
404 
405## Konklusyon
406 
407Bawat framework ay may malinaw na pusta:
408 
409- **LangGraph** ay inoptimize para sa kontrol  -  ikaw ang magpapasya sa bawat transisyon
410- **CrewAI** ay inoptimize para sa kolaborasyon  -  gumagana ang mga agent bilang koponan
411- **OpenAI Agents SDK** ay inoptimize para sa pagkasimple  -  minimal abstraction, malinis na handoffs
412- **Claude Agent SDK** ay inoptimize para sa awtonomiya  -  bigyan ito ng mga tool at hayaan itong gumana
413 
414Ang tamang pagpipilian ay depende sa iyong workflow, iyong koponan, at iyong kasalukuyang stack. Piliin ang tumutugma sa iyong pangunahing use case, pag-aralan itong mabuti, at dalhin ang iba kapag nakarating ka sa kanilang sweet spot.
415