Pagbuo ng AI Workflows gamit ang Multi-Agent Frameworks

Ang mga ahente ay nakarehistro bilang mga bahagi na matatawag sa system

Bago gumawa ng anuman ang isang ahente, kailangang malaman ng balangkas na ito ay umiiral. Nangangahulugan ito na sabihin sa system ang pangalan ng ahente, kung ano ang responsable nito, at kung anong mga tool o impormasyon ang maa-access nito.

Sa karamihan ng mga framework, nangyayari ang setup na ito sa pamamagitan ng configuration file o ilang code, kung saan mo tutukuyin ang tungkulin ng bawat ahente at kung paano ito i-activate. Halimbawa, maaari mong sabihin sa system:

"Ito ang tagaplano. Binabasa nito ang input ng user at nagpapasya kung ano ang susunod na gagawin."
"Ito ang verifier. Ito ay tumatagal ng impormasyon ng user at nagbabalik ng booking_id at impormasyon ng user."

Kapag nakarehistro na, maaaring "tawagan" ng framework ang mga ahente sa pamamagitan ng pangalan, ibig sabihin, alam nito kung paano patakbuhin ang bawat isa kapag turn na nila sa workflow.

Ang ahente sa pagruruta ang magpapasya kung aling ahente ang susunod na tatakbo

Pinangangasiwaan ng ahente ng tagaplano o function ng controller ang pagruruta ng ahente ng AI . Tinitingnan nito ang pinakabagong output ng bot, ang kasalukuyang kasaysayan ng pag-uusap, at kung minsan ang orihinal na input ng user upang magpasya kung ano ang susunod na kailangang mangyari.

Ang ilang mga tagaplano ay maagap na nakabatay - kinukuha nila ang isang mensahe ng system at ilalabas ang pangalan ng susunod na ahente na tatakbo.

Ang iba ay gumagamit ng hardcoded logic o flow graphs, depende sa AI agent frameworks na pinagtatrabahuhan mo.

Kinukuha ng framework ang output na iyon at ginagamit ito upang tawagan ang susunod na ahente. Ang router ang magpapasya kung sino ang dapat gawin ang gawain sa halip na gawin ang gawain.

Ipinapasa ang data sa pagitan ng mga ahente gamit ang mga mensahe

Ang mga ahente ay hindi direktang nagbabahagi ng memorya. Kapag ang isa ay natapos na sa pagtakbo, ang output nito ay naka-package sa isang mensahe — karaniwang isang diksyunaryo o JSON object — at ipinapasa sa susunod na ahente bilang input.

Pinangangasiwaan ng framework ang paglilipat. Iniimbak nito ang mensahe sa isang shared memory space o direktang ipinapasa ito sa input interface ng susunod na ahente, depende sa kung paano nakaayos ang system.

Ang mga mensahe ay kadalasang naglalaman ng higit pa sa nilalaman:

• Sino ang nagpadala nito (ahente o user)
• Saan ito nanggaling sa workflow
• Paano ito dapat gamitin (hal., trigger, input, desisyon)
• Mga opsyonal na sukatan tulad ng bilang ng token o timestamp

Tinutulungan ng kontekstong ito ang mga gawain ng ruta ng system nang malinis at pinapanatili ang mga ahente na nahiwalay sa isa't isa.

Sinusubaybayan ang pagpapatupad gamit ang estado ng daloy ng trabaho at mga trigger

Sinusubaybayan ng framework kung ano ang nangyari sa ngayon — kung aling mga ahente ang tumakbo, kung ano ang kanilang ibinalik, at kung ano ang kailangan pang mangyari. Ito ay naka-imbak sa isang bagay ng estado, na nag-a-update pagkatapos ng bawat hakbang.

Ang mga trigger ang magpapasya kung ano ang susunod. Gumagamit sila ng mga halaga ng output o kundisyon para sanga ang daloy.

Hinahayaan nito ang system na sumulong nang walang hardcoding logic sa bawat ahente. Ang estado ang nagtutulak sa daloy ng trabaho, hindi ang mga ahente mismo.

I-scale ang lohika nang walang labis na karga ng isang ahente

Marami lang magagawa ang isang ahente ng AI bago ito maging gulo ng mga prompt, tool, at hindi malinaw na responsibilidad. Hinahayaan ka ng mga multi-agent na framework na hatiin ang logic na iyon sa mga nakatutok na ahente, bawat isa ay humahawak ng isang malinaw na gawain.

Sa halip na pahabain ang isang ahente, maaari kang magtalaga ng mga partikular na hakbang — tulad ng pagkuha, pagpapatunay, o pagpapatupad — upang paghiwalayin ang mga ahente at palakihin ang system nang paisa-isa.

Debug agent collaboration na may ganap na visibility

Kapag nagtutulungan ang mga ahente ng AI, maaaring mahirap masubaybayan ang mga isyu. Ipinapakita sa iyo ng mga framework kung ano ang nakuha ng bawat ahente, kung ano ang ibinalik nito, at kung saan ito tumigil.

Hindi mo hulaan kung ano ang nasira — sinisiyasat mo ang mga handoff at inayos ito nang direkta. Ang ganitong uri ng visibility ang dahilan kung bakit napapamahalaan ang pakikipagtulungan ng ahente ng AI.

Muling gumamit ng mga ahente sa mga daloy ng trabaho

Kung gumagana ang isang ahente, muling gamitin ito. Hinahayaan ka ng Framework na isaksak ang parehong ahente sa iba't ibang daloy nang hindi ito muling sinusulat. Pinapanatili nitong pare-pareho ang mga bagay at ginagawang mas mabilis ang pagsubok.

Halimbawa, ang isang validation agent na sumusuri sa mga input ng user o pagpapatotoo ay maaaring gamitin sa parehong customer service chatbots at booking chatbots , saanman nalalapat ang parehong logic.

Awtomatikong pangasiwaan ang mga pagkabigo at muling pagsubok

Kapag nabigo ang isang ahente, maaaring subukang muli, laktawan, o sumulong ang framework. Hindi mo kailangang isulat ang lohika sa iyong sarili.  

Ginagawang mas maaasahan ng built-in na fallback ang mga daloy ng trabaho nang walang dagdag na trabaho, at ang ganitong uri ng pagiging maaasahan ay siyang nagpapagana sa mga real-world system.

Bumuo ng mga daloy ng ahente na madaling baguhin

Kapag hinati-hati mo ang mga gawain sa mga ahente, hindi mo kailangang isagawa muli ang buong system sa tuwing may magbabago.

Maaari mong i-update ang isang tagaplano nang hindi hinahawakan ang pagpapatupad, o baguhin kung paano tumugon ang isang ahente nang hindi muling sinusulat ang iba.

Ang kadalian ng pag-access ay kabayaran—Iniulat ng Salesforce na ang mga team na gumagamit ng ahenteng AI ay nakakatipid ng 11 oras bawat empleyado bawat linggo, salamat sa isang bahagi ng kakayahang umangkop ng mga daloy ng trabaho.

1. Botpress

Botpress ay isang visual development platform para sa pagbuo ng mga ahente ng AI na maaaring mag-coordinate sa mga hakbang, tungkulin, at channel.

Sa halip na mag-wire ng logic sa code, tutukuyin mo kung paano kumikilos ang mga ahente gamit ang mga daloy, memorya, kundisyon, at mga tool na tawag.

Ang pag-uugali ng maraming ahente ay binuo sa paligid ng mga tagubilin, daloy ng trabaho, at panlabas na tool. Ang bawat node sa a Botpress gumaganap ang daloy bilang isang nakatutok na yunit, na may sariling mga tagubilin at saklaw.

Maaari mong hatiin ang pangangatwiran sa maraming Autonomous at Static Node, magdagdag ng mga layer ng pagpapatunay, o ruta ang input ng user sa pamamagitan ng logic ng desisyon na nakabatay sa tool sa halip na pangasiwaan ang lahat sa isang hakbang.

Ang memorya ay saklaw sa bawat daloy, kaya ginagamit lamang ng mga ahente ang kailangan nila. Malinaw na tinukoy ang mga input at output, at maaaring direktang idagdag ang mga tool call sa pamamagitan ng mga built-in na pagsasama .

Mga Pangunahing Tampok

• Orkestrasyon ng visual na ahente gamit ang mga daloy at node
• Saklaw na memorya at variable na kontrol sa pagitan ng mga node
• Multi-turn memory, fallback logic, at muling pagsubok
• Paggamit ng tool sa pamamagitan ng mga tawag sa API, webhook, at input ng function

2. LangChain

Ang LangChain ay isang developer-first framework para sa pagbuo LLM -pinalakas na mga application sa pamamagitan ng pagsasama-sama ng mga kadena ng mga prompt, tool, at memorya.

Nagsimula ito bilang isang paraan sa istraktura LLM mga tawag na may mga tool tulad ng paghahanap at mga calculator, ngunit unti-unting lumawak sa isang malawak na ecosystem.

Ang isang release ay nagbigay-priyoridad sa "mga ahente," pagkatapos ay "mga katulong," pagkatapos ay "mga runnable." Ang resulta ay isang makapangyarihang toolkit na kayang gawin ang halos anumang bagay, ngunit madalas na nangangailangan ng oras upang mag-navigate.

Maaari kang magtalaga ng mga toolkit at bumuo ng lohika sa pagruruta sa mga ahente. Kung saan ito kumikinang ay modularity — ang mga bahagi ay magagamit muli, mix-and-match, at mahusay na pinagsama sa mga panlabas na API.

Ngunit magsusulat ka ng mas maraming glue code kaysa sa inaasahan. At sa mabilis na paglilipat ng mga abstraction, sulit na suriin kung ang paraan na iyong ginagamit ay pa rin ang ginustong isa.

Mga Pangunahing Tampok

• Modular chaining ng mga prompt, tool, at memory
• Sumasama sa LLMs , mga tindahan ng vector, at mga API
• Opsyonal na pagsubaybay at mga eval sa LangSmith

3. CrewAI

Pinapadali ng CrewAI ang pagbuo ng mga multi-agent na daloy ng trabaho kung saan ang bawat ahente ay may tinukoy na tungkulin at gawain. Lumilikha ka ng isang crew, magtatalaga ng mga layunin, at ang mga ahente ay nag-coordinate sa pamamagitan ng isang nakabahaging manager.

Isa ito sa pinakamabilis na paraan upang imodelo ang pakikipagtulungan ng ahente nang hindi nagsusulat ng lohika ng orkestra mula sa simula.

Tamang-tama para sa mga setup tulad ng mga pares ng planner–executor, mga daloy ng research–reviewer, o anumang gawaing nakabatay sa team kung saan malinis ang paghahati ng mga responsibilidad.

Ngunit sa sandaling simulan mo ang pagdaragdag ng pagiging kumplikado, ang abstraction ay nagiging mahigpit. Mas kaunting flexibility kung paano at kailan tatakbo ang mga ahente, at ang pagbabago ng gawi ay kadalasang nangangahulugan ng paglabas sa mga default ng framework.

Mga Pangunahing Tampok

• Pag-setup ng ahente na nakabatay sa tungkulin na may mga pangalan, layunin, at memorya
• Sinusuportahan ang sequential at parallel agent execution
• Nakabahaging memorya ng crew para sa pakikipagtulungan ng ahente
• Madaling pagsasama sa mga tool, function, at custom na prompt

4. AutoGPT

Ang AutoGPT ang unang proyektong nagpakita kung ano ang hitsura nito kapag binigyan mo ng layunin ang isang GPT chatbot at hinayaan itong tumakbo — magplano, mag-isip, magsaliksik, at magsagawa nang walang palagiang input ng tao.

Tinutukoy mo ang layunin, at ang AutoGPT ay umiikot sa pamamagitan ng mga hakbang sa pangangatwiran, gumagawa ng mga sub-goal, tumatawag ng mga tool, at nagsasaayos ng diskarte nito habang tumatakbo.

Ito ay isang napakalaking hakbang sa pagpapadama ng pag-uugali ng ahente na nagsasarili at pabago-bago. Ngunit hindi ito binuo para sa katumpakan.

Ang loop ng gawain ay malutong, at ang mga ahente ay malamang na makaalis sa muling pagsusulat ng parehong plano o paghabol sa mga hindi nauugnay na subtask.

Maaari kang mag-wire sa memorya, mga tool, at mga API — ngunit ang pagsasama-sama ng lahat ay kadalasang humahantong sa mga hindi mahulaan na daloy na mahirap i-debug o patnubayan.

Mga Pangunahing Tampok

• Ahente na hinihimok ng layunin na may pag-udyok sa sarili at pagpaplano ng gawain
• Awtomatikong pagbuo ng subtask at loop ng pagpapatupad
• Sinusuportahan ang paggamit ng tool sa pamamagitan ng mga plugin at API call
• Napapalawak gamit ang mga custom na script, function, at integration

5. Autogen

Ang Autogen ay isang open-source na framework mula sa Microsoft na tumutuon sa mga pag-uusap ng maraming ahente, kung saan nakikipag-ugnayan ang mga ahente sa pamamagitan ng mga structured, turn-based na mga mensahe.

Ito ay lalong mabuti kapag gusto mong kontrolin ang bawat palitan, tulad ng sa pagpaplano – execution loops o human-in-the-loop system.

Ang Autogen ay kumikinang sa transparency. Maaari kang mag-inject ng mga function sa kalagitnaan ng convo, mga pagpapasya sa ruta sa pamamagitan ng custom na lohika, at subaybayan kung ano mismo ang sinabi ng bawat ahente at kung bakit.

Ngunit ang pag-scale ay nangangailangan ng trabaho. Ang orkestrasyon ng mensahe ay flexible, ngunit hindi na-abstract — ikaw pa rin ang namamahala sa mga kasaysayan, mga config ng ahente, at lohika ng hakbang.

Para sa mga setup ng pananaliksik, kinokontrol na pagsubok, o reproducible na gawi ng ahente, isa ito sa mga pinakatumpak na frameworks doon.

Mga Pangunahing Tampok

• Turn-based multi-agent na balangkas ng komunikasyon
• Sinusuportahan ang human-in-the-loop at function-calling agent
• Transparent na pagsubaybay sa mensahe at custom na logic injection

Hakbang 1: Tukuyin kung saan nasira ang iyong logic na nag-iisang ahente

Maghanap ng lugar sa iyong bot o system kung saan nagsimulang kumalat ang mga bagay — mahahabang senyas o nakakadena na tool na tawag na parang naka-bold. Yan ang entry point mo. Narito ang ilang karaniwang mga halimbawa na madaling makita:

1. Isang daloy ng refund na nag-parse ng input ng user, nagsusuri ng pagiging karapat-dapat, nag-isyu ng refund, at nagpapadala ng kumpirmasyon — lahat sa isang loop
2. Isang onboarding sequence na nangongolekta ng data, nagpapatunay ng mga form, nagtatalaga ng mga uri ng user, at nagti-trigger ng mga email sa iisang prompt chain

Sa halip na muling idisenyo ang buong system, ibinubukod mo lang ang daloy ng trabaho na nagpapakita na ng mga bitak.

Hakbang 2: Tukuyin ang mga tungkulin bago mo pindutin ang framework

Kapag nahanap mo na ang magulo na lohika, hatiin ito sa mga tunay na responsibilidad.

Kung may nagpapatunay ng input, iyon ay isang ahente. Kung may humahawak sa isang panlabas na pagkilos, iba iyon.

Isulat ito sa simpleng wika — sapat lang upang ilantad kung nasaan ang mga handoff.

At kapag nasa harap mo na ang lahat, makikita mo kung ano talaga ang kailangang paghiwalayin at kung ano ang maaaring gumuho. Nagbibigay din ito sa iyo ng pakiramdam para sa kung anong uri ng balangkas ang kailangan mo.

Ang bawat tungkulin ay dapat na parang isang bagay na maaari mong subukan nang mag-isa.

Hakbang 3: Piliin ang balangkas

Pumili ng platform na akma sa iyong istilo ng daloy ng trabaho.

• Visual : Botpress , kung gusto mo ng mga daloy na nakabatay sa node at nasasakupan na memorya.
• Code-first : LangChain o CrewAI kung komportable kang mag-wiring logic sa Python.

Ang balangkas ay nagpapasya kung paano nakarehistro, na-trigger, at nakakonekta ang mga ahente.

Hakbang 4: Buuin ang unang daloy ng trabaho

Ngayon gawing mga ahente ang mga tungkuling iyon. Tukuyin ang mga ito sa loob ng iyong framework — bigyan ang bawat isa ng pangalan, trabaho nito, at anumang tool o API access na kailangan nito.

Kapag nasa lugar na sila, ikonekta sila. Gamitin ang anumang pagruruta na ibinibigay ng framework upang lumipat mula sa isang ahente patungo sa susunod.

Ang layunin dito ay upang makakuha ng isang kumpletong daloy ng trabaho na tumatakbo sa dulo, kasama ang mga ahente na nananatili sa kanilang linya.

Hakbang 5: Patakbuhin ang system at siyasatin ang bawat handoff

I-trigger ang buong workflow — mula simula hanggang matapos — at subaybayan kung ano ang mangyayari. Dapat mong bantayan kung ano ang natatanggap ng bawat ahente, kung ano ang ibinabalik nito, at kung ang daloy ay gumagalaw nang malinis sa pagitan nila.

Kung ang isang ahente ay nalilito sa pag-input, malamang na nasasakupan mo ang mga bagay na mali. Kung ang lohika ay tumalon nang hindi inaasahan, ang iyong pagruruta ay kailangang ayusin. 

Kapag malinis na ang mga handoff, mayroon kang gumaganang sistema.

Panatilihing sentralisado ang pangunahing lohika

Iwasang magpakalat ng mga kritikal na desisyon sa maraming ahente. Mas madaling mapanatili at subukan kapag ang pangunahing pangangatwiran ay nangyayari sa isang lugar sa halip na hatiin sa mga bahaging magkadugtong.

Tukuyin ang mga input at output ng ahente sa harap

Ang bawat ahente ay dapat magkaroon ng malinaw na tinukoy na kontrata — kung ano ang kailangan nito, kung ano ang ibinabalik nito. Ginagawa nitong mas madali ang mga ahente na magpalit o magsaksak sa mga bagong daloy ng trabaho nang hindi sinisira ang lohika ng daloy.

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

Kung hindi mo makita kung ano ang sinasabi ng mga ahente sa isa't isa, hindi mo maaaring i-debug ang anuman. Siguraduhin na ang bawat input at output ay naka-log na may sapat na konteksto upang masubaybayan pabalik ang daloy.

Gumamit ng scoped memory para mabawasan ang ingay at gastos

Ibigay lamang sa bawat ahente ang kontekstong kailangan nito. Ang ganap na pag-access sa memorya ay humahantong sa mga bloated na prompt, mas mataas na paggamit ng token, at hindi mahuhulaan na pag-uugali mula sa mga ahente na dapat ay nakatutok.

Paano ko malalaman kung ang aking proyekto sa AI ay talagang nangangailangan ng isang multi-agent na balangkas, o kung ang isang ahente ay sapat na?

Ang iyong proyekto sa AI ay malamang na nangangailangan ng isang multi-agent na framework kung ang mga prompt o workflow ng iyong solong ahente ay naging masyadong mahaba o mahirap i-debug, lalo na kapag humahawak ng maraming natatanging gawain, samantalang ang mas simpleng mga kaso ng paggamit tulad ng pangunahing Q&A o single-purpose na mga bot ay kadalasang gumagana nang maayos sa isang ahente lamang.

Ang pagbuo ba gamit ang isang multi-agent na balangkas ay para lamang sa malalaking proyekto ng negosyo, o angkop din ba ito para sa maliliit na startup?

Ang pagbuo gamit ang isang multi-agent na balangkas ay hindi lamang para sa malalaking negosyo — ang maliliit na startup ay maaari ding makinabang, dahil kahit ang mga katamtamang proyekto ay nakakakuha ng mas madaling pag-debug kapag ang mga kumplikadong gawain ay nahahati sa mga dalubhasang ahente sa halip na itambak ang lahat sa isang malaki, mahirap pamahalaan na loop.

Ang paggamit ba ng isang multi-agent system ay nangangahulugan na kailangan kong hatiin ang lahat sa magkahiwalay na mga ahente, o maaari ko bang paghaluin ang single at multi-agent na lohika? 

Ang paggamit ng multi-agent system ay hindi nangangahulugan na kailangan mong hatiin ang lahat sa magkakahiwalay na ahente; maaari mong paghaluin ang single-agent logic para sa mga simpleng gawain habang inirereserba ang multi-agent na orkestra para sa mga kumplikadong daloy ng trabaho.

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

Naiiba ang isang multi-agent system sa paggamit ng maraming API o microservice dahil nag-coordinate ito ng mga dalubhasang AI agent na may natatanging mga tungkulin at kakayahan sa pangangatwiran na nagpapasa ng mga structured na mensahe at estado, habang ang mga API at microservice ay nangangasiwa ng mga discrete na function ngunit hindi independiyenteng nag-oorganisa ng mga kumplikadong daloy ng trabaho.

Paano maihahambing ang halaga ng pagpapatakbo ng mga multi-agent system sa pagpapatakbo ng isang malaking LLM ?

Ang halaga ng pagpapatakbo ng mga multi-agent system ay maaaring mas mababa kaysa sa pagpapatakbo ng isang malaking LLM dahil ang mga mas maliliit at dalubhasang ahente ay maaaring humawak ng mga partikular na gawain nang mahusay nang hindi nag-aaksaya ng mga token sa mahabang pag-prompt o paulit-ulit na konteksto, ngunit nagpapakilala rin ito ng karagdagang overhead para sa pamamahala ng orkestrasyon at komunikasyon sa pagitan ng mga ahente, kaya ang mga matitipid ay nakasalalay sa iyong pagiging kumplikado ng kaso ng paggamit.