Pagbuo ng AI na Daloy gamit ang Multi-Agent Frameworks

Karamihan sa mga developer na sumusubok gumawa ng AI agent ay nagsisimula sa isang malaking language model loop—isang system prompt at marahil isang tool o dalawa—at para sa maliliit na gawain, sapat na iyon.

Ngunit kapag gusto mo na ng istraktura, nagsisimula nang magulo ang sistema. Nagiging hindi inaasahan ang mga resulta, mahirap nang i-debug ang mga daloy, at nauubos ang tokens mo sa paulit-ulit na gawain imbes na sa pag-usad.

Pinapayagan ka ng multi-agent workflows na bumuo ng AI agents na parang isang team na may malinaw na tungkulin at nakikita kung paano ginagawa ang mga desisyon at nagtutulungan para sa iisang layunin.

Ano ang Multi-Agent Framework?

Ang multi-agent framework ay ang imprastraktura na ginagamit mo para bumuo, magpatakbo, at mag-manage ng maraming AI agent nang magkakasabay.

Ito ang imprastraktura na humahawak kung paano nag-uusap ang mga agent at paano naililipat ang mga gawain sa pagitan nila.

Kung nagtatrabaho ka sa multi-agent system, ang framework ang nagpapagana sa kanila.

Sa pinakapayak, ginagawang mga agent na may tiyak na tungkulin at predictable na paraan ng operasyon ang raw malalaking modelong pangwika (LLM).

Sa halip na gumawa ng orchestration logic mula sa simula, nagbibigay ang framework ng istraktura, kontrol, at paulit-ulit na proseso.

Multi-Agent Frameworks: Mahahalagang Konsepto

Paano Gumagana ang Multi-Agent Frameworks?

Nagbibigay ang multi-agent frameworks ng estruktura kung paano na-trigger ang mga agent, paano sila nagpapasa ng datos, at paano sinusubaybayan ng sistema ang progreso.

Nagbibigay ito ng mga pundasyon para sa koordinasyon ng mga agent na kayang sumabay sa lumalaking komplikasyon at magamit sa aktwal na mga aplikasyon.

Halimbawa, maaaring gumamit ng multi-agent na setup para paganahin ang isang WhatsApp chatbot. Sa ganitong kaso, iba't ibang ahente ang maaaring humawak ng mga gawain tulad ng pag-book, pagproseso ng refund, o beripikasyon, na nagtutulungan sa likod ng eksena nang hindi umaasa sa isang malaking bot lang.

Ang mga agent ay nirehistro bilang maaaring tawaging bahagi sa sistema

Bago makakilos ang isang ahente, kailangan munang malaman ng framework na ito ay umiiral. Nangangahulugan ito ng pagsasabi sa sistema ng pangalan ng ahente, ang tungkulin nito, at anong mga kasangkapan o impormasyong maaari nitong ma-access.

Sa karamihan ng mga framework, ang setup na ito ay ginagawa sa pamamagitan ng configuration file o ilang code, kung saan itinatakda mo ang tungkulin ng bawat agent at kung paano ito i-activate. Halimbawa, maaari mong sabihin sa sistema:

“Ito ang planner. Binabasa nito ang input ng user at nagpapasya kung ano ang susunod na gagawin.”
“Ito ang verifier. Kinukuha nito ang impormasyon ng user at ibinabalik ang booking_id at impormasyon ng user.”

Kapag nairehistro na, maaaring "tawagin" ng framework ang mga ahente sa pangalan, ibig sabihin alam nito kung paano patakbuhin ang bawat isa kapag sila na ang susunod sa daloy ng trabaho.

Ang routing agent ang nagpapasya kung aling ahente ang susunod na tatakbo

Ang planner agent o controller function ang namamahala sa pag-route ng AI agent. Tinitingnan nito ang pinakahuling output ng bot, kasaysayan ng pag-uusap, at kung minsan pati ang orihinal na input ng user upang magpasya kung ano ang susunod na hakbang.

May ilang planner na nakabatay sa prompt — tumatanggap sila ng mensahe ng sistema at naglalabas ng pangalan ng susunod na agent na tatakbo.

Ang iba ay gumagamit ng hardcoded na lohika o flow graph, depende sa AI agent framework na ginagamit mo.

Kinukuha ng framework ang output na iyon at ginagamit ito para tawagin ang susunod na agent. Ang router ang nagdedesisyon kung sino ang gagawa ng gawain imbes na gawin mismo ang gawain.

Ipinapasa ang datos sa pagitan ng mga agent gamit ang mga mensahe

Hindi direktang nagbabahagi ng memorya ang mga agent. Kapag natapos na ang isa, ang output nito ay inilalagay sa isang mensahe — kadalasan ay dictionary o JSON object — at ipinapasa sa susunod na agent bilang input.

Ang framework ang namamahala sa paglipat. Maaari nitong itago ang mensahe sa isang shared memory space o ipasa ito direkta sa input interface ng susunod na agent, depende sa estruktura ng sistema.

Madalas na may kasamang higit pa sa nilalaman ang mga mensahe:

• Sino ang nagpadala (agent o user)
• Saan ito nagmula sa workflow
• Paano ito dapat gamitin (hal. trigger, input, desisyon)
• Opsyonal na sukatan tulad ng bilang ng token o oras

Tinutulungan ng kontekstong ito ang sistema na maayos na mag-route ng mga gawain at mapanatiling hiwalay ang mga agent sa isa’t isa.

Ang pagsubaybay sa pagpapatupad ay gamit ang estado ng workflow at mga trigger

Tinutunton ng balangkas kung ano na ang mga nangyari — aling mga ahente ang tumakbo, ano ang kanilang ibinalik, at ano pa ang kailangang gawin. Nakaimbak ito sa isang bagay na tinatawag na 'state object' na ina-update pagkatapos ng bawat hakbang.

Ang mga trigger ang nagtatakda ng susunod na mangyayari. Ginagamit nila ang output na halaga o kondisyon para hatiin ang daloy.

Pinapayagan nitong umusad ang sistema nang hindi kailangang i-hardcode ang lohika sa bawat agent. Ang estado ang nagtutulak ng workflow, hindi ang mga agent mismo.

Pangunahing Benepisyo ng Paggamit ng Multi-Agent Frameworks

Palawakin ang lohika nang hindi binibigatan ang isang ahente lang

Hanggang isang AI agent lang ang kayang gawin bago ito maging magulo dahil sa dami ng prompt, tool, at hindi malinaw na tungkulin. Sa multi-agent frameworks, puwede mong hatiin ang lohika sa mga agent na may kanya-kanyang malinaw na gawain.

Sa halip na isang ahente lang ang gumagawa ng lahat, maaari mong italaga ang mga partikular na hakbang — tulad ng pagkuha ng datos, pag-validate, o pagsasagawa — sa magkakaibang ahente at palakihin ang sistema unti-unti.

I-debug ang pagtutulungan ng ahente na may buong visibility

Kapag nagtutulungan ang mga AI agent, mahirap sundan ang mga isyu. Ipinapakita ng mga framework kung ano ang natanggap ng bawat agent, ano ang ibinalik, at saan ito tumigil.

Hindi mo huhulaan kung saan nagka-aberya — tinitingnan mo mismo ang mga palitan at inaayos ito agad. Ang ganitong uri ng malinaw na pagtingin ang nagpapadali sa pamamahala ng pagtutulungan ng AI agents.

Gamitin muli ang mga agent sa iba’t ibang workflow

Kung gumagana ang isang agent, gamitin mo ulit ito. Pinapayagan ka ng mga framework na ikabit ang parehong agent sa iba’t ibang daloy nang hindi na muling isinusulat. Pinananatili nitong pare-pareho ang proseso at nagpapabilis ng pagsubok.

Halimbawa, ang validation agent na sumusuri ng input ng user o authentication ay maaaring gamitin sa parehong customer service chatbot at booking chatbot, saanman kailangan ang parehong lohika.

Awtomatikong hawakan ang mga pagkabigo at pag-uulit

Kapag pumalya ang isang ahente, maaaring subukan muli ng framework, laktawan ito, o magpatuloy. Hindi mo na kailangang isulat ang lohikang iyon.

Ang built-in na fallback ay nagpapalakas ng pagiging maaasahan ng workflow nang walang dagdag na trabaho, at ang ganitong klase ng reliability ang nagpapatakbo ng mga tunay na sistema.

Bumuo ng mga daloy ng ahente na madaling baguhin

Kapag hinati-hati mo ang mga gawain sa mga agent, hindi mo na kailangang baguhin ang buong sistema tuwing may pagbabago.

Maaari mong i-update ang planner nang hindi ginagalaw ang execution, o baguhin kung paano tumugon ang isang agent nang hindi nire-rewrite ang iba.

Malaki ang naitutulong ng madaling access na ito—iniulat ng Salesforce na nakakatipid ng 11 oras kada empleyado bawat linggo ang mga team na gumagamit ng agentic AI, dahil na rin sa kakayahang magbago-bago ng mga workflow.

Nangungunang 5 Multi-Agent Frameworks

Ang pagpili ng balangkas para sa maraming ahente ay nakadepende sa kung ano ang iyong nililikha at kung gaano mo gustong kontrolin ang kilos, komunikasyon, at pagbangon mula sa pagkabigo ng mga ahente.

Ang pinakamahusay na mga framework ay may kanya-kanyang kalakip na kompromiso — may ilan na mahusay para sa estrukturadong mga daloy ng trabaho, ang iba naman ay nagbibigay ng higit na kalayaan kapalit ng kaunting kalinawan.

Pumili ng bagay na akma sa pangangailangan ng iyong team at kung gaano kalayo mo gustong dalhin ang sistema.

1. Botpress

Ang Botpress ay isang biswal na plataporma sa pagbuo ng AI agent na kayang mag-ugnay-ugnay sa mga hakbang, papel, at channel.

Sa halip na mag-wire ng lohika sa code, tinutukoy mo kung paano kumikilos ang mga ahente gamit ang flows, memorya, kondisyon, at mga tawag sa tool.

Ang multi-agent na kilos ay nakabatay sa mga tagubilin, workflow, at panlabas na kasangkapan. Bawat node sa Botpress flow ay nagsisilbing nakatutok na yunit, may sariling tagubilin at saklaw.

Maaari mong hatiin ang pangangatwiran sa maraming Autonomous at Static Node, magdagdag ng mga validation layer, o idaan ang input ng user sa tool-based na decision logic sa halip na gawin lahat sa isang hakbang.

Ang memorya ay nakalaan sa bawat flow, kaya ginagamit lang ng mga ahente ang kailangan nila. Malinaw ang input at output, at puwedeng idagdag ang mga tawag sa tool direkta gamit ang built-in na integrations.

Pangunahing Katangian

• Biswal na orkestrasyon ng ahente gamit ang mga daloy at node
• Saklaw ng memorya at kontrol ng variable sa pagitan ng mga node
• Multi-turn na memorya, fallback na lohika, at retries
• Paggamit ng tool sa pamamagitan ng API call, webhook, at function input

2. LangChain

Ang LangChain ay isang Tagalog-forward na balangkas para sa mga developer na bumubuo ng mga aplikasyon gamit ang LLM sa pamamagitan ng pag-uugnay ng mga prompt, kasangkapan, at alaala.

Nagsimula ito bilang paraan ng pag-istruktura ng LLM calls gamit ang mga tool tulad ng search at calculator, ngunit unti-unting lumawak sa isang malawak na ecosystem.

Isang release ang nagbigay-priyoridad muna sa “agents,” pagkatapos ay “assistants,” at saka “runnables.” Ang resulta ay isang makapangyarihang toolkit na halos lahat ay kayang gawin, ngunit madalas ay matagal bago ito mapag-aralan.

Maaari kang magtalaga ng mga toolkit at bumuo ng routing logic sa pagitan ng mga ahente. Ang lakas nito ay nasa modularidad — puwedeng gamitin muli ang mga bahagi, pagsamahin, at mahusay na nakakabit sa mga panlabas na API.

Ngunit baka mas marami kang kailangang isulat na glue code kaysa inaasahan. At dahil mabilis magbago ang mga abstraction, mainam na suriin kung ang paraan na ginagamit mo ay siya pa ring inirerekomenda.

Pangunahing Katangian

• Modular na pagkakabit ng mga prompt, tool, at memorya
• Nakikiintegrate sa LLMs, vector stores, at APIs
• Opsyonal na tracing at eval gamit ang LangSmith

3. CrewAI

Pinapadali ng CrewAI ang paggawa ng mga workflow na maraming ahente kung saan bawat isa ay may tiyak na tungkulin at gawain. Gumagawa ka ng crew, nagtatakda ng mga layunin, at nagtutulungan ang mga ahente sa pamamagitan ng isang shared manager.

Isa ito sa pinakamabilis na paraan para magmodelo ng pagtutulungan ng mga ahente nang hindi kailangang magsulat ng orchestration logic mula sa simula.

Mainam para sa mga setup tulad ng magkaparehang tagaplano–tagapagpatupad, daloy ng pananaliksik–tagasuri, o anumang gawaing pangkoponan kung saan malinaw ang pagkakahati ng mga tungkulin.

Ngunit kapag nagsimula ka nang magdagdag ng komplikasyon, nagiging mahigpit ang abstraction. Mas kaunti ang kalayaan kung paano at kailan tatakbo ang mga ahente, at madalas kailangan mong lumihis sa default ng framework para baguhin ang kilos.

Pangunahing Katangian

• Setup ng agent batay sa papel na may pangalan, layunin, at memorya
• Sumusuporta sa sunud-sunod at sabayang pagpapatupad ng agent
• Pinagsasaluhang memorya ng crew para sa kolaborasyon ng mga agent
• Madaling pagsama sa mga tool, function, at custom na prompt

4. AutoGPT

Ang AutoGPT ang unang proyektong nagpakita kung ano ang mangyayari kapag binigyan mo ng layunin ang isang GPT chatbot at hinayaang tumakbo ito — magplano, mag-isip, magsaliksik, at magsagawa nang hindi kailangang laging may input ng tao.

Itakda mo ang layunin, at inuulit ng AutoGPT ang mga hakbang ng pangangatwiran, lumilikha ng mga sub-layunin, tumatawag ng mga tool, at inaayos ang estratehiya habang nagpapatuloy.

Malaking hakbang ito para gawing mas awtonomo at dynamic ang kilos ng agent. Pero hindi ito ginawa para sa eksaktong resulta.

Ang task loop ay madaling masira, at madalas na natitigilan ang mga ahente sa paulit-ulit na pag-uulit ng parehong plano o sa pagsunod sa mga hindi mahalagang subtask.

Maaari kang magdagdag ng memorya, mga kasangkapan, at API—ngunit ang pagsasama-sama ng lahat ay kadalasang nagreresulta sa hindi inaasahang daloy na mahirap i-debug o kontrolin.

Pangunahing Katangian

• Goal-driven na agent na may sariling prompting at task planning
• Awtomatikong paggawa at pagpapatupad ng subtask loop
• Sumusuporta sa paggamit ng tool sa pamamagitan ng plugins at API calls
• Nadadagdagan gamit ang custom na script, function, at integration

5. Autogen

Ang Autogen ay isang open-source na balangkas mula sa Microsoft na nakatuon sa pag-uusap ng maraming ahente, kung saan ang mga ahente ay nakikipag-ugnayan gamit ang estrukturadong, salit-salit na mga mensahe.

Lalo itong maganda kung gusto mong kontrolado ang bawat palitan, gaya sa planning–execution loops o human-in-the-loop systems.

Namumukod-tangi ang Autogen sa transparency. Maaari kang mag-inject ng function sa gitna ng usapan, mag-route ng desisyon gamit ang custom logic, at masusubaybayan mo mismo kung ano at bakit sinabi ng bawat ahente.

Ngunit kailangan ng pagsisikap upang mapalawak ito. Flexible ang pag-oorganisa ng mensahe, ngunit hindi ito abstrakto — ikaw pa rin ang nag-aasikaso ng kasaysayan, mga configuration ng agent, at lohika ng bawat hakbang.

Para sa mga pananaliksik, kontroladong pagsubok, o reproducible na kilos ng agent, isa ito sa pinaka-tumpak na framework na magagamit.

Pangunahing Katangian

• Balangkas ng turn-based para sa komunikasyon ng maraming ahente
• Sumusuporta sa human-in-the-loop at function-calling agents
• Transparent na pagsubaybay ng mensahe at pasingit ng sariling lohika

Paano Bumuo gamit ang Multi-Agent Frameworks

Ang pinakamadaling paraan upang magsimula ay pumili ng isang tunay na daloy ng gawain — isang bagay na masyado nang kumplikado para sa isang ahente lang — at hatiin ito sa ilang simpleng bahagi.

Isipin ang isang lead generation chatbot, booking flow, o anumang proseso kung saan nagkakagulo ang lohika, beripikasyon, at aksyon.

Bigyan ng sariling ahente ang bawat hakbang, tapos ikonekta gamit ang routing at messaging tools ng framework.

Hakbang 1: Tukuyin kung saan bumabagsak ang iyong single-agent na lohika

Maghanap ng bahagi sa iyong bot o sistema kung saan nagsimula nang magkalat-kalat ang mga bagay — mahahabang prompt o magkakabit na tawag sa tool na parang idinugtong lang. Iyan ang iyong panimulang punto. Narito ang ilang karaniwang halimbawa na madaling makita:

1. Isang proseso ng refund na sumusuri sa input ng user, tinitingnan ang pagiging karapat-dapat, nagbabalik ng bayad, at nagpapadala ng kumpirmasyon—lahat sa isang ikot.
2. Isang onboarding na sunod-sunod na hakbang na kumokolekta ng datos, nagbeberipika ng mga form, nagtatalaga ng uri ng user, at nagpapadala ng email sa iisang chain ng prompt

Sa halip na baguhin ang buong sistema, ihiwalay mo lang ang daloy ng trabaho na nagpapakita na ng mga bitak.

Hakbang 2: Tukuyin ang mga tungkulin bago gamitin ang framework

Kapag nakita mo na ang magulong lohika, hatiin ito sa mga totoong tungkulin.

Kung may nagva-validate ng input, iyon ay isang agent. Kung may humahawak ng external na aksyon, iyon ay isa pa.

Isulat ito sa payak na wika — sapat upang makita kung saan nagkakaroon ng palitan ng gawain.

Kapag nakita mo na ang lahat sa harap mo, makikita mo kung ano talaga ang kailangang paghiwalayin at ano ang puwedeng pagsamahin. Makakatulong din ito para malaman mo kung anong uri ng framework ang kailangan mo.

Dapat parang puwedeng i-test nang mag-isa ang bawat papel.

Hakbang 3: Piliin ang balangkas

Pumili ng platformang akma sa iyong istilo ng trabaho.

• Visual: Botpress, kung gusto mo ng node-based na flows at scoped memory.
• Code-first: LangChain o CrewAI kung komportable kang mag-wire ng logic gamit ang Python.

Ang framework ang nagtatakda kung paano nirehistro, pinapagana, at pinag-uugnay ang mga ahente.

Hakbang 4: Bumuo ng unang daloy ng trabaho

Ngayon, gawing agent ang mga role na iyon. I-define sila sa loob ng framework mo—bigyan ng pangalan, tungkulin, at kung anong tool o API access ang kailangan nila.

Kapag naayos na sila, ikonekta ang mga ito. Gamitin ang anumang routing na inaalok ng framework para lumipat mula sa isang agent papunta sa susunod.

Layunin dito na mapatakbo ang isang kumpletong daloy ng trabaho mula simula hanggang wakas, na ang mga ahente ay nananatili sa kanilang takdang tungkulin.

Hakbang 5: Patakbuhin ang sistema at suriin ang bawat handoff

I-trigger ang buong workflow — mula umpisa hanggang dulo — at subaybayan ang nangyayari. Dapat mong tingnan kung ano ang natatanggap ng bawat agent, ano ang ibinabalik, at kung maayos bang dumadaloy sa pagitan nila.

Kung nalilito ang agent sa input, malamang mali ang scope mo. Kung biglang tumalon ang lohika, kailangan ayusin ang routing mo.

Kapag maayos na ang mga handoff, gumagana na ang iyong sistema.

Pinakamahuhusay na Paraan sa Paggamit ng Multi-Agent Frameworks

Ang pagpili ng framework ay simula pa lang. Mas mahalaga kung paano mo idinisenyo, sinubukan, at pinamahalaan ang mga workflow na gagawin mo rito.

Habang nagiging mas modular at awtonomo ang mga AI system, lalong nagiging mahirap ang pagsubaybay.

Panatilihing sentralisado ang pangunahing lohika

Iwasang ikalat ang mahahalagang desisyon sa maraming agent. Mas madaling i-maintain at subukan kung ang pangunahing pag-iisip ay nasa isang lugar lang at hindi hati-hati sa magkakahiwalay na bahagi.

Itakda agad ang mga input at output ng ahente

Dapat malinaw ang kontrata ng bawat agent — ano ang tinatanggap at ano ang ibinabalik. Dahil dito, mas madaling palitan o idagdag ang mga agent sa bagong workflow nang hindi nasisira ang lohika ng flow.

I-log ang bawat mensaheng ipinapasa sa pagitan ng mga agent

Kung hindi mo nakikita ang usapan ng mga ahente, hindi mo madi-debug ang anuman. Siguraduhing naka-log ang bawat input at output na may sapat na konteksto para masundan ang daloy.

Gamitin ang scoped memory para mabawasan ang ingay at gastos

Bigyan lamang ng kinakailangang konteksto ang bawat ahente. Ang pagbibigay ng buong access sa memorya ay nagdudulot ng mahahabang prompt, mas mataas na paggamit ng token, at hindi inaasahang kilos mula sa mga ahenteng dapat ay nakatuon lang.

Simulan ang Pagbuo ng AI na Marunong Mag-ugnayan

Karamihan sa mga sistema ay bumabagsak kapag kailangan na ng tunay na koordinasyon. Binibigyan ka ng Botpress ng kontrol kung paano magpapasa ng gawain ang mga agent — sa malinaw na mga tungkulin at lohika, puwede mong subukan at maintindihan.

Pinapayagan ka rin nitong maglipat ng datos nang maayos sa pagitan ng mga flow. Maaari mong subaybayan ang bawat hakbang gamit ang multi-turn logs na nagpapakita kung anong tool ang ginamit, bakit ito pinatakbo, at paano ito ginamit sa workflow.

Sa halip na prompt tuning at hallucination control, tutok ka sa tunay na functionality — paggawa ng mga ahenteng kumikilos na parang software.

Simulan ang paggawa ngayon — libre ito.

FAQs

Paano ko malalaman kung kailangan talaga ng multi-agent framework ang AI project ko, o sapat na ang isang agent lang?

Malamang na kailangan mo ng multi-agent framework kung masyado nang mahaba o mahirap i-debug ang prompt o workflow ng iyong single agent, lalo na kung maraming magkakaibang gawain ang hinahawakan. Para sa simpleng Q&A o single-purpose na bot, sapat na ang isang agent.

Ang paggawa gamit ang multi-agent framework ba ay para lang sa malalaking enterprise project, o bagay din sa maliliit na startup?

Ang paggawa gamit ang multi-agent framework ay hindi lang para sa malalaking negosyo — makikinabang din ang maliliit na startup, dahil mas madaling mag-debug kapag hinati ang komplikadong gawain sa mga espesyalisadong agent kaysa isiksik lahat sa isang malaking, mahirap pamahalaang loop.

Kapag gumamit ako ng multi-agent system, kailangan ko bang hatiin lahat sa magkakahiwalay na agent, o puwede kong pagsamahin ang single at multi-agent na lohika?

Ang paggamit ng multi-agent system ay hindi nangangahulugang kailangan mong hatiin lahat sa magkakahiwalay na agent; maaari mong pagsamahin ang single-agent na lohika para sa mga simpleng gawain at gamitin ang multi-agent orchestration para sa mas komplikadong daloy.

Paano naiiba ang multi-agent system sa simpleng paggamit ng maraming API o microservice sa aking aplikasyon?

Ang multi-agent system ay naiiba sa paggamit ng maraming API o microservice dahil ito ay nag-uugnay ng mga espesyal na AI agent na may kanya-kanyang tungkulin at kakayahan sa pagdedesisyon na nagpapasa ng estrukturadong mensahe at estado, samantalang ang mga API at microservice ay tumutugon lamang sa hiwa-hiwalay na gawain at hindi kayang mag-orchestrate ng komplikadong workflow nang mag-isa.

Paano ikinukumpara ang gastos ng pagpapatakbo ng multi-agent systems sa pagpapatakbo ng isang malaking LLM?

Maaaring mas mababa ang gastos ng pagpapatakbo ng multi-agent system kaysa sa isang malaking LLM dahil ang mas maliliit at espesyalisadong agent ay mas episyente sa mga tiyak na gawain at hindi nasasayang ang tokens sa mahahabang prompt o paulit-ulit na konteksto. Ngunit may dagdag na gastos sa pamamahala ng orchestration at komunikasyon ng mga agent, kaya nakadepende ang pagtitipid sa pagiging kumplikado ng iyong use case.