Paano ko masisiguro ang tagumpay ng aking proyekto bilang AI agent?

Para matiyak ang tagumpay ng iyong proyekto ng AI agent, malinaw na tukuyin ang trabaho sa isang pangungusap at magpasya sa antas ng awtonomiya na komportable ka. Bukod pa rito, magpatupad ng mahigpit na mga tool scheme, logging, at mga estratehiya sa pagpapatunay upang maiwasan ang mga karaniwang pagkakamali at magbigay-daan para sa mas mahusay na pag-troubleshoot.

Ano ang dapat kong isaalang-alang kapag nagdidisenyo ng mga tool para sa aking AI agent?

Kapag nagdidisenyo ng mga tool para sa iyong AI agent, siguraduhing ang mga ito ay limitado ang pokus, naka-type, at may pahintulot. Iwasan ang mga generic na tool na maaaring magsagawa ng anumang aksyon. Sa halip, lumikha ng mga partikular na function call na magagamit ng agent upang mapanatili ang kaligtasan at pagiging maaasahan.

Paano ako magtatakda ng malinaw na mga kondisyon ng paghinto para sa aking AI agent?

Para magtakda ng malinaw na mga kondisyon ng paghinto para sa iyong AI agent, tukuyin ang maximum na bilang ng mga hakbang na maaari nitong gawin, kasama ang mga timeout at mga pagsusuri sa pagkumpleto. Makakatulong ito na maiwasan ang pagiging maipit ng agent sa mga loop at matiyak na maaari nitong palalain ang mga isyu kung kinakailangan.

Ano ang pinakamahusay na paraan upang pamahalaan ang memorya sa isang ahente ng AI?

Pamahalaan ang memorya sa iyong AI agent sa pamamagitan ng paghihiwalay nito sa mga panandalian at pangmatagalang bahagi. Panatilihing siksik ang panandaliang memorya, na nakatuon sa mga kasalukuyang hakbang at plano, habang ginagamit ang pangmatagalang memorya para sa matatag na impormasyon tulad ng mga kagustuhan ng gumagamit at mga panuntunan sa organisasyon.

Mayroon bang mga partikular na padron para sa pagpaplano ng mga gawain sa loob ng isang ahente ng AI?

Oo, maaaring gamitin ang iba't ibang mga pattern ng pagpaplano, tulad ng mga checklist para sa mga nahuhulaang gawain, mga ReAct loop para sa mga adaptive na tugon sa mga output ng tool, at mga modelo ng superbisor-manggagawa na nagbibigay-daan sa paghihiwalay ng tungkulin para sa mga kumplikadong proyekto. Pumili ng paraan ng pagpaplano batay sa mga partikular na kinakailangan ng iyong ahente.

Paano ko epektibong masusuri ang pagganap ng aking AI agent?

Para masuri ang performance ng iyong AI agent, gumawa ng scenario suite na kinabibilangan ng mga happy path, edge case, at mga malabong request. Magbigay ng marka sa mga resulta batay sa mga sukatan tulad ng task success rate, response time, at recovery mula sa mga error para patuloy na mapabuti ang mga kakayahan nito.

Paano Gumawa ng Ahente ng AI

Maikling sagot: Para bumuo ng isang AI agent na gumagana sa praktika, ituring ito bilang isang kontroladong loop: kumuha ng input, magpasya sa susunod na aksyon, tumawag ng isang tool na may makitid na saklaw, obserbahan ang resulta, at ulitin hanggang sa pumasa ang isang malinaw na "tapos na" na pagsusuri. Magagamit ito kapag ang gawain ay maraming hakbang at nakabatay sa tool; kung ang isang prompt lamang ang nakalutas nito, laktawan ang agent. Magdagdag ng mahigpit na tool schemas, mga limitasyon sa hakbang, pag-log, at isang validator/critic upang kapag nabigo ang mga tool o hindi malinaw ang mga input, ang agent ay tataas sa halip na mag-loop.

Mga pangunahing punto:

Controller loop: Ipatupad ang input→act→observe repetition na may tahasang stop conditions at max steps.

Disenyo ng Kagamitan: Panatilihing makitid, naka-type, may pahintulot, at may patunay ang mga kagamitan upang maiwasan ang kaguluhan sa "gawin_ang_kahit_anu".

Kalinisan sa memorya: Gumamit ng compact short-term state at long-term retrieval; iwasang itapon ang mga kumpletong transcript.

Paglaban sa maling paggamit: Magdagdag ng mga allowlist, limitasyon sa rate, idempotency, at "dry-run" para sa mga mapanganib na aksyon.

Kakayahang Masubukan: Panatilihin ang isang hanay ng mga senaryo (mga pagkabigo, kalabuan, mga iniksyon) at patakbuhin muli sa bawat pagbabago.

Mga artikulong maaaring gusto mong basahin pagkatapos nito:

🔗 Paano sukatin ang pagganap ng AI
Matuto ng mga praktikal na sukatan upang masukat ang bilis, katumpakan, at pagiging maaasahan.

🔗 Paano makipag-usap sa AI
Gumamit ng mga prompt, konteksto, at mga follow-up upang makakuha ng mas mahuhusay na sagot.

🔗 Paano suriin ang mga modelo ng AI
Paghambingin ang mga modelo gamit ang mga pagsubok, rubrics, at mga resulta ng gawain sa totoong mundo.

🔗 Paano i-optimize ang mga modelo ng AI
Pagbutihin ang kalidad at gastos sa pamamagitan ng pag-tune, pagpuputol, at pagsubaybay.

1) Ano ang isang ahente ng AI, sa terminong pang-normal na tao 🧠

Ang isang AI agent ay isang loop. Mga dokumento ng "Agents" ng LangChain

Ayan na. Isang loop na may utak sa gitna.

Input → think → act → observe → repeat. Papel ng ReAct (katwiran + act)

Saan:

Ang input ay isang kahilingan ng user o isang kaganapan (bagong email, support ticket, sensor ping).
Ang pag-iisip ay isang modelo ng wika na nangangatwiran tungkol sa susunod na hakbang.
Tumatawag ang Act ng isang tool (maghanap ng mga internal na dokumento, magpatakbo ng code, gumawa ng ticket, mag-draft ng tugon). Gabay sa pagtawag ng OpenAI Function
Obserbasyon ang output ng tool.
Ang paulit-ulit ay ang bahaging nagpaparamdam dito na "ahente" sa halip na "madaldal". Mga dokumento ng "Ahente" ni LangChain

Ang ilang ahente ay karaniwang matatalinong macro. Ang iba naman ay kumikilos na parang isang junior operator na kayang pagsabayin ang mga gawain at makabawi mula sa mga error. Parehong mahalaga.

Isa pa, hindi mo kailangan ng ganap na awtonomiya. Sa katunayan… malamang ayaw mo nito 🙃

2) Kailan ka dapat bumuo ng ahente (at kailan hindi dapat) 🚦

Bumuo ng ahente kapag:

Ang trabaho ay maraming hakbang at nagbabago depende sa kung ano ang mangyayari sa kalagitnaan.
Ang trabaho ay nangangailangan ng paggamit ng mga kagamitan (mga database, CRM, pagpapatupad ng code, pagbuo ng file, mga browser, mga internal na API). Mga dokumento ng "Mga Kagamitan" ng LangChain
Gusto mo ng mga paulit-ulit na resulta na may mga guardrail, hindi lang mga minsanang sagot.
Maaari mong tukuyin ang "tapos na" sa paraang kayang suriin ng computer, kahit na maluwag lang.

Huwag bumuo ng ahente kapag:

Isang simpleng prompt + tugon ang makakalutas nito (huwag kang masyadong mag-engineer, magagalit ka rin sa sarili mo sa huli).
Kailangan mo ng perpektong determinismo (ang mga ahente ay maaaring maging pare-pareho, ngunit hindi robotic).
Wala kang anumang tool o data na magagamit para kumonekta - kung gayon kadalasan ay puro vibes lang ang lahat.

Maging prangka tayo: kalahati ng mga "proyekto ng AI agent" ay maaaring isang daloy ng trabaho na may ilang mga panuntunang nagsasanga. Pero teka, minsan mahalaga rin ang vibe 🤷♂️

3) Ano ang bumubuo sa isang mahusay na bersyon ng isang AI agent ✅

Narito ang seksyong “Ano ang bumubuo sa isang magandang bersyon ng” na hiniling mo, maliban sa medyo prangka akong magpapaliwanag:

Ang isang mahusay na bersyon ng isang ahente ng AI ay hindi iyong nag-iisip nang husto. Ito ay iyong:

Alam kung ano ang pinapayagang gawin (mga hangganan ng saklaw)
Maaasahang gumagamit ng mga tool (mga nakabalangkas na tawag, muling pagsubok, mga timeout) Gabay sa pagtawag ng OpenAI Function AWS “Mga timeout, muling pagsubok, at backoff nang may jitter”
Pinapanatiling malinis ang estado (memoryang hindi nabubulok) LangChain “Pangkalahatang-ideya ng memorya”
Ipinapaliwanag ang mga aksyon nito (mga audit trail, hindi mga lihim na pangangatwiran) NIST AI RMF 1.0 (pagkakatiwalaan at transparency)
Huminto nang naaayon (mga pagsusuri sa pagkumpleto, mga pinakamataas na hakbang, pag-angat) Mga dokumento ng "Ahente" ng LangChain
Ligtas na nabibigo (humihingi ng tulong, hindi nagha-hallucinate ng awtoridad) NIST AI RMF 1.0
Nasusubukan (maaari mo itong patakbuhin sa mga naka-kahong senaryo at makakuha ng mga resulta)

Kung hindi masubukan ang iyong ahente, isa itong napaka-kumpiyansang slot machine. Masaya sa mga party, nakakatakot sa produksyon 😬

4) Ang mga pangunahing bloke ng pagbuo ng isang ahente (ang "anatomiya" 🧩)

Karamihan sa mga solidong ahente ay may mga pirasong ito:

A) Ang loop ng controller 🔁

Ito ang orkestrador:

kunin ang goal
magtanong sa modelo para sa susunod na aksyon
patakbuhin ang kagamitan
idagdag ang obserbasyon
ulitin hanggang matapos ang mga dokumentong "Ahente" ng LangChain

B) Mga Kagamitan (kilala rin bilang mga kakayahan) 🧰

Ang mga kagamitan ang nagpapabisa sa isang ahente: Mga dokumentong "Mga Kagamitan" ng LangChain

mga query sa database
pagpapadala ng mga email
paghila ng mga file
tumatakbong kodigo
pagtawag sa mga internal na API
pagsusulat sa mga spreadsheet o CRM

C) Memorya 🗃️

Dalawang uri ang mahalaga:

panandaliang memorya: ang kasalukuyang konteksto ng pagpapatakbo, mga kamakailang hakbang, kasalukuyang plano
pangmatagalang memorya: mga kagustuhan ng gumagamit, konteksto ng proyekto, nakuhang kaalaman (madalas sa pamamagitan ng mga embedding + isang vector store) papel na RAG

D) Patakaran sa pagpaplano at pagpapasya 🧭

Kahit hindi mo ito tawaging "pagpaplano", kailangan mo ng isang pamamaraan:

mga checklist
Papel na ReAct na istilong “mag-isip pagkatapos ay gamitin”
mga graph ng gawain
mga pattern ng superbisor-manggagawa
mga pattern ng superbisor-manggagawa Microsoft AutoGen (multi-agent framework)

E) Mga barandilya at ebalwasyon 🧯

mga pahintulot
mga iskema ng ligtas na kagamitan Mga Nakabalangkas na Output ng OpenAI
pagpapatunay ng output
mga limitasyon ng hakbang
pagtotroso
mga pagsubok sa NIST AI RMF 1.0

Oo, mas maituturing itong inhinyero kaysa sa pag-udyok. Na… ganoon talaga ang punto.

5) Talahanayan ng Paghahambing: mga sikat na paraan upang bumuo ng isang ahente 🧾

Nasa ibaba ang isang makatotohanang "Talahanayan ng Paghahambing" - na may ilang kakaibang katangian, dahil ang mga totoong koponan ay kakaiba 😄

Kasangkapan / Balangkas	Madla	Presyo	Bakit ito gumagana	Mga Tala (maliit na kaguluhan)
LangChain	mga tagapagtayo na mahilig sa mga piyesang istilo-lego	parang libre + imprastraktura	malaking ecosystem para sa mga kagamitan, memorya, at mga kadena	mabilis maluto sa spaghetti kung hindi mo malinaw na mapapangalanan ang mga bagay-bagay
LlamaIndex	Mga koponan na maraming RAG	parang libre + imprastraktura	malalakas na pattern ng pagkuha, pag-iindeks, mga konektor	maganda kapag ang ahente mo ay parang "search + act"... na karaniwan naman
Pamamaraan sa istilo ng OpenAI Assistants	mga koponan na naghahangad ng mas mabilis na pag-setup	batay sa paggamit	mga built-in na pattern ng pagtawag ng tool at estado ng pagpapatakbo	hindi gaanong flexible sa ilang sulok, pero malinis para sa maraming app	Nagpapatakbo ang OpenAI ng API sa pagtawag ng function ng OpenAI Assistants
Semantikong Kernel	mga developer na nagnanais ng nakabalangkas na orkestrasyon	parang malaya	maayos na abstraksyon para sa mga kasanayan/tungkulin	parang "malinis ang negosyo" - minsan papuri na rin 'yan 😉
AutoGen	mga eksperimentador na may maraming ahente	parang malaya	mga pattern ng kolaborasyon ng ahente-sa-ahente	maaaring magsalita nang labis; magtakda ng mahigpit na mga patakaran sa pagtatapos
CrewAI	mga tagahanga ng "mga pangkat ng mga ahente"	parang malaya	madaling ipahayag ang mga tungkulin + gawain + mga handoff	pinakamahusay na gumagana kapag ang mga gawain ay presko, hindi malambot
Tumpok ng dayami	mga tao sa paghahanap + pipelines	parang malaya	solidong mga tubo, pagkuha, mga bahagi	mas kaunting "teatro ng ahente", mas "praktikal na pabrika"
Gumawa ng sarili mong loop (pasadyang loop)	mga mahilig sa kontrol (mapagmahal)	oras mo	kaunting mahika, pinakamataas na kalinawan	kadalasan ang pinakamahusay na pangmatagalan... hanggang sa baguhin mo ang lahat 😅

Walang iisang panalo. Ang pinakamahusay na pagpipilian ay depende kung ang pangunahing trabaho ng iyong ahente ay pagkuha, pagpapatupad ng tool, koordinasyon ng maraming ahente, o automation ng daloy ng trabaho.

6) Paano Gumawa ng AI Agent nang sunud-sunod (ang aktwal na recipe) 🍳🤖

Ito ang bahaging nilalaktawan ng karamihan, pagkatapos ay nagtataka kung bakit kumikilos ang ahente na parang raccoon sa pantry.

Hakbang 1: Bigyang-kahulugan ang trabaho sa isang pangungusap 🎯

Mga Halimbawa:

"Gumawa ng tugon ng customer gamit ang konteksto ng patakaran at tiket, pagkatapos ay humingi ng pag-apruba."
"Siyasatin ang isang ulat ng bug, kopyahin ito, at magmungkahi ng solusyon."
"Gawing mga gawain, may-ari, at deadline ang mga di-perpektong tala ng pulong."

Kung hindi mo ito kayang bigyang-kahulugan nang simple, hindi rin kaya ng ahente mo. Ibig kong sabihin, kaya naman, pero mag-iimprovise lang ito, at ang improvisation ang dahilan kung bakit namamatay ang badyet.

Hakbang 2: Magpasya sa antas ng kalayaan (mababa, katamtaman, maanghang) 🌶️

Mababang awtonomiya: nagmumungkahi ng mga hakbang, "aprubahan" ng mga pag-click ng tao
Medium: nagpapatakbo ng mga tool, nagda-draft ng output, nagpapalala sa kawalan ng katiyakan
Mataas: isinasagawa mula dulo hanggang dulo, nagpi-ping lamang sa mga tao sa mga eksepsiyon

Magsimula nang mas mababa kaysa sa gusto mo. Maaari mo itong dagdagan pa sa ibang pagkakataon.

Hakbang 3: Piliin ang iyong modelo ng estratehiya 🧠

Karaniwan mong pipiliin ang:

isang matibay na modelo para sa lahat (simple)
isang malakas na modelo + mas maliit na modelo para sa mga murang hakbang (klasipikasyon, pagruruta)
mga espesyalisadong modelo (pananaw, kodigo, pagsasalita) kung kinakailangan

Magpasya rin:

pinakamataas na token
temperatura
kung pinapayagan mo ba ang mga bakas ng mahahabang pangangatwiran sa loob (maaari mo, ngunit huwag ilantad ang hilaw na kadena ng mga pag-iisip sa mga end user)

Hakbang 4: Tukuyin ang mga tool na may mahigpit na mga iskema 🔩

Ang mga kagamitan ay dapat na:

makitid
na-type
pinahintulutan
napatunayang mga nakabalangkas na output ng OpenAI

Sa halip na isang tool na tinatawag na do_anything(input: string), make:

search_kb(query: string) -> resulta[]
create_ticket(pamagat: string, katawan: string, prayoridad: enum) -> ticket_id
send_email(to: string, subject: string, body: string) -> status Gabay sa pagtawag ng tungkulin ng OpenAI

Kung bibigyan mo ang ahente ng chainsaw, huwag magulat kapag pinuputol nito ang isang halamang bakod sa pamamagitan ng pag-alis din ng bakod.

Hakbang 5: Buuin ang controller loop 🔁

Pinakamababang pag-ikot:

Magsimula sa layunin + panimulang konteksto
Tanungin ang modelo: “Susunod na aksyon?”
Kung tawagin ang tool - isagawa ang tool
Idagdag ang obserbasyon
Suriin ang kondisyon ng paghinto
Ulitin (na may pinakamataas na hakbang) mga dokumentong "Ahente" ng LangChain

Idagdag:

mga timeout
mga pagsubok muli (mag-ingat - maaaring umulit ang mga pagsubok muli) AWS “Mga timeout, pagsubok muli, at pag-backoff nang may jitter”
pag-format ng error sa tool (malinaw, nakabalangkas)

Hakbang 6: Maingat na magdagdag ng memorya 🗃️

Panandaliang: panatilihing updated ang isang maliit na "buod ng estado" sa bawat hakbang. LangChain "Pangkalahatang-ideya ng memorya"
Pangmatagalan: mag-imbak ng mga pangmatagalang impormasyon (mga kagustuhan ng gumagamit, mga panuntunan ng organisasyon, mga matatag na dokumento).

Panuntunan ng hinlalaki:

kung madalas itong magbago - panatilihin itong panandalian lamang
kung ito ay matatag - iimbak nang pangmatagalan
kung ito ay sensitibo - itago nang kaunti (o huwag na lang)

Hakbang 7: Magdagdag ng pagpapatunay at isang "critic" pass 🧪

Isang mura at praktikal na disenyo:

bumubuo ng resulta ang ahente
Sinusuri ng validator ang istruktura at mga limitasyon
opsyonal na mga pagsusuri ng modelo ng kritiko para sa mga nawawalang hakbang o mga paglabag sa patakaran NIST AI RMF 1.0

Hindi perpekto, pero nakakasagabal ito sa nakakagulat na dami ng kalokohan.

Hakbang 8: I-log ang lahat ng bagay na pagsisisihan mo sa hindi pag-log 📜

Talaan:

mga tawag sa kagamitan + mga input + mga output
mga desisyong ginawa
mga pagkakamali
mga pangwakas na output
mga token at latency panimulang aklat sa pag-obserba ng OpenTelemetry

Hinaharap - magpapasalamat ka. Kasalukuyan - makakalimutan mo. Ganoon talaga ang buhay 😵💫

7) Pagtawag gamit ang mga kagamitan na hindi makakasira ng iyong kaluluwa 🧰😵

Sa tool calling, nagiging tunay na software engineering ang "Paano Gumawa ng AI Agent".

Gawing maaasahan ang mga kagamitan (mabuti ang pagiging maaasahan)

Ang mga maaasahang kagamitan ay:

deterministiko
makitid ang saklaw
madaling subukan
ligtas na patakbuhin muli ang Stripe na "Mga kahilingang Idempotent"

Magdagdag ng mga guardrail sa tool layer, hindi lang mga prompt

Ang mga prompt ay magagalang na mungkahi. Ang pagpapatunay ng tool ay isang nakakandadong pinto. Mga Nakabalangkas na Output ng OpenAI

Gawin:

mga allowlist (kung aling mga tool ang maaaring tumakbo)
pagpapatunay ng input
Mga limitasyon sa rate Gabay sa mga limitasyon sa rate ng OpenAI
mga pagsusuri ng pahintulot bawat user/org
"Dry-run mode" para sa mga mapanganib na aksyon

Disenyo para sa bahagyang pagkabigo

Nabigo ang mga tool. Gumagalaw ang mga network. Mag-e-expire ang auth. Ang isang ahente ay dapat:

bigyang-kahulugan ang mga pagkakamali
subukan muli gamit ang backoff kung naaangkop Istratehiya sa pagsubok muli ng Google Cloud (backoff + jitter)
pumili ng mga alternatibong kagamitan
lumala kapag natigil

Isang tahimik na epektibong trick: ibalik ang mga nakabalangkas na error tulad ng:

uri: error_ng_awtorisasyon
uri: hindi_natagpuan
uri: rate_limited
Upang ang modelo ay makatugon nang matalino sa halip na mag-panic.

8) Alaala na nakakatulong sa halip na gumugulo sa iyo 👻🗂️

Makapangyarihan ang memorya, ngunit maaari rin itong maging isang tambakan ng basura.

Panandaliang memorya: panatilihin itong siksik

Gamitin:

huling N hakbang
isang tumatakbong buod (ina-update bawat loop)
kasalukuyang plano
kasalukuyang mga limitasyon (badyet, oras, mga patakaran)

Kung ilalagay mo ang lahat sa konteksto, makukuha mo ang:

mas mataas na gastos
mas mabagal na latency
mas maraming kalituhan (oo, kahit na noon)

Pangmatagalang memorya: pagbawi sa halip na "pagpupuno"

Karamihan sa "pangmatagalang memorya" ay mas katulad ng:

mga pag-embed
tindahan ng vector
pagkuha ng augmented generation (RAG) na papel ng RAG

Hindi kabisado ng ahente. Kinukuha nito ang mga pinaka-kaugnay na snippet sa oras ng pagpapatakbo. LlamaIndex “Panimula sa RAG”

Mga praktikal na tuntunin sa memorya

Itabi ang mga "kagustuhan" bilang mga tahasang katotohanan: "Gusto ng user ang mga bullet summary at ayaw niya ng mga emoji" (lol, wala rito 😄)
Itabi ang mga "desisyon" gamit ang mga timestamp o bersyon (kung hindi ay tataas ang mga kontradiksyon)
Huwag magtago ng mga sikreto maliban na lang kung talagang kailangan

At narito ang aking di-perpektong metapora: ang alaala ay parang refrigerator. Kung hindi mo ito lilinisin, sa kalaunan ang iyong sandwich ay magiging lasang sibuyas at panghihinayang.

9) Mga pattern ng pagpaplano (mula simple hanggang sa magarbo) 🧭✨

Ang pagpaplano ay isa lamang kontroladong dekomposisyon. Huwag itong gawing mistiko.

Pattern A: Tagaplano ng checklist ✅

Naglalabas ang modelo ng listahan ng mga hakbang
Isinasagawa nang paunti-unti
Mga update sa katayuan ng checklist

Mahusay para sa onboarding. Simple, maaaring subukan.

Padron B: Ulitin ang ReAct (dahilan + kilos) 🧠→🧰

nagpapasya ang modelo sa susunod na paggamit ng tool
nagmamasid sa output
inuulit ang papel na ReAct

Ito ang klasikong pakiramdam ng ahente.

Pattern C: Superbisor-manggagawa 👥

hinahati ng superbisor ang layunin sa mga gawain
mga manggagawa na nagsasagawa ng mga espesyalisadong gawain
Pinagsasama ng superbisor ang mga resulta ng Microsoft AutoGen (multi-agent framework)

Mahalaga ito kapag ang mga gawain ay maaaring pagsabayin, o kapag gusto mo ng iba't ibang "tungkulin" tulad ng:

mananaliksik
tagapagkodigo
editor
Tagasuri ng QA

Pattern D: Magplano-pagkatapos-isagawa nang may muling pagpaplano 🔄

gumawa ng plano
isagawa
kung magbago ang realidad sa mga resulta ng kagamitan, magplano muli

Pinipigilan nito ang ahente na matigas ang ulo na sumunod sa isang masamang plano. Ginagawa rin ito ng mga tao, maliban na lang kung sila ay pagod, kung saan sa ganitong kaso ay sinusunod din nila ang mga masamang plano.

10) Kaligtasan, pagiging maaasahan, at hindi pagkatanggal sa trabaho 🔐😅

Kung makakagawa ng aksyon ang iyong ahente, kailangan mo ng disenyo para sa kaligtasan. Hindi "masarap magkaroon". Kailangan. NIST AI RMF 1.0

Mahigpit na mga limitasyon

pinakamataas na hakbang bawat takbo
pinakamataas na tawag sa kagamitan kada minuto
pinakamataas na gastos kada sesyon (token budget)
mga pinaghihigpitang tool sa likod ng pag-apruba

Paghawak ng datos

i-redecode ang mga sensitibong input bago mag-log
magkahiwalay na kapaligiran (dev vs production)
mga pahintulot sa tool na may pinakamababang pribilehiyo

Mga limitasyon sa pag-uugali

pilitin ang ahente na banggitin ang mga panloob na snippet ng ebidensya (hindi mga panlabas na link, mga panloob na sanggunian lamang)
nangangailangan ng mga flag ng kawalan ng katiyakan kapag mababa ang kumpiyansa
humiling ng "magtanong ng mga tanong na nagpapaliwanag" kung ang mga input ay hindi malinaw

Ang isang maaasahang ahente ay hindi ang may pinakatiwala sa sarili. Ito ay ang taong alam kung kailan ito nanghuhula... at sinasabi ito.

11) Pagsusulit at ebalwasyon (ang bahaging iniiwasan ng lahat) 🧪📏

Hindi mo mapapabuti ang hindi mo masusukat. Oo, medyo cheesy ang linyang iyan, pero nakakainis ang totoo.

Gumawa ng set ng senaryo

Gumawa ng 30-100 test case:

masasayang landas
mga gilid na kaso
mga kaso ng "pagkabigo ng kagamitan"
mga hindi malinaw na kahilingan
mga adversarial prompt (mga pagtatangka ng prompt injection) OWASP Top 10 para sa mga LLM App OWASP LLM01 Prompt Injection

Mga resulta ng iskor

Gumamit ng mga sukatan tulad ng:

antas ng tagumpay ng gawain
oras bago matapos
bilis ng pagbawi ng error sa tool
rate ng halusinasyon (mga pahayag na walang ebidensya)
antas ng pag-apruba ng tao (kung nasa supervised mode)

Mga pagsubok sa regresyon para sa mga prompt at tool

Anumang oras na magbago ka:

iskema ng kagamitan
mga tagubilin sa sistema
lohika ng pagkuha
format ng memorya
Patakbuhin muli ang suite.

Sensitibong mga hayop ang mga ahente. Parang mga halamang pang-bahay, pero mas mahal.

12) Mga pattern ng pag-deploy na hindi makakaubos ng iyong badyet 💸🔥

Magsimula sa iisang serbisyo

API ng tagakontrol ng ahente
mga serbisyo sa kagamitan sa likod nito
pag-log + pagsubaybay sa panimulang aklat sa pagmamasid ng OpenTelemetry

Magdagdag ng mga kontrol sa gastos nang maaga

mga resulta ng pagkuha ng caching
pag-compress ng estado ng pag-uusap gamit ang mga buod
paggamit ng mas maliliit na modelo para sa pagruruta at pagkuha
nililimitahan ang "malalim na pag-iisip" sa pinakamahirap na mga hakbang

Karaniwang pagpili ng arkitektura

stateless controller + panlabas na state store (DB/redis)
Ang mga tool call ay idempotent kung saan posible. Ang Stripe "Mga kahilingang idempotent"
pila para sa mahahabang gawain (para hindi mo laging bukas ang isang web request)

Gayundin: gumawa ng "kill switch". Hindi mo ito kakailanganin hangga't hindi mo talaga ito kailangan 😬

13) Mga pangwakas na tala - ang maikling bersyon kung Paano Gumawa ng Isang AI Agent 🎁🤖

Kung wala ka nang ibang maalala, tandaan mo ito:

Ang Paano Gumawa ng AI Agent ay kadalasang tungkol sa pagbuo ng ligtas na loop sa paligid ng isang modelo. Mga dokumento ng "Agents" ng LangChain
Magsimula sa isang malinaw na layunin, mababang awtonomiya, at mahigpit na mga kagamitan. Mga Nakabalangkas na Output ng OpenAI
Magdagdag ng memorya sa pamamagitan ng pagkuha, hindi sa walang katapusang pagpupuno ng konteksto. Papel na RAG
Maaaring simple lang ang pagpaplano - malaki ang maitutulong ng mga checklist at muling pagpaplano.
Ang pag-log at mga pagsubok ay ginagawang isang bagay na maaari mong i-promote ang kaguluhan ng ahente. OpenTelemetry observability primer
Ang mga guardrail ay kabilang sa code, hindi lamang sa mga prompt. OWASP Top 10 para sa mga LLM App

Ang isang ahente ay hindi mahika. Ito ay isang sistemang gumagawa ng magagandang desisyon nang madalas na sapat na mahalaga… at inaamin ang pagkatalo bago pa ito magdulot ng pinsala. Tahimik na nakakaaliw, sa isang paraan 😌

At oo, kung gagawin mo ito nang tama, parang pagkuha ng isang maliit na digital intern na hindi natutulog, paminsan-minsan ay nagpapanic, at mahilig sa mga papeles. Kaya, parang isang intern talaga.

Halimbawa sa totoong buhay: Pagbuo ng isang support triage AI agent 🎫🤖

Senaryo

Isipin ang isang maliit na SaaS team na tumatanggap ng 120-180 support ticket kada linggo. Karamihan sa mga ticket ay hindi naman kumplikado, pero matagal pa rin ang mga ito: pag-reset ng password, mga tanong sa pagsingil, mga ulat ng bug, mga kahilingan sa feature, at mga mensaheng "ito ba ang inaasahang pag-uugali?".

Kayang magsulat ng mga tugon ang isang simpleng chatbot, ngunit hindi nito maaasahang masusuri ang katayuan ng account, mahahanap ang knowledge base, mauuri ang mga pangangailangang pang-apura, o makapagpasya kung kailan kailangang makialam ang isang tao. Dito nagiging makabuluhan ang isang ahente.

Ang layunin ay hindi ang ganap na palitan ang suporta. Ang layunin ay bumuo ng isang low-autonomy agent na magbabasa ng bagong ticket, mangangalap ng konteksto, bubuo ng tugon, at magruruta ng ticket sa tamang pila. Inaaprubahan pa rin ng isang tao ang anumang bagay na nakaharap sa customer.

Ang kailangan ng katulong

Para ligtas na gumana, ang ahente ay nangangailangan ng isang maliit at kontroladong hanay ng mga input at kagamitan:

Ang papasok na teksto ng tiket
Uri ng plano ng customer, edad ng account, at kamakailang katayuan ng pagsingil
Mga kamakailang talaan ng pagbabago ng produkto o mga kilalang insidente
Mga artikulo sa panloob na sentro ng tulong
Isang tool sa pag-update ng tiket na may limitadong mga field
Isang draft na tool sa pagsagot, hindi isang tool sa pagpapadala ng email
Isang malinaw na patakaran sa pagpapataas ng escalation

Ang listahan ng mga kagamitan ay dapat manatiling makitid nang may layunin:

search_help_centre(query)
get_customer_status(customer_id)
check_known_incidents(product_area)
update_ticket_category(ticket_id, kategorya, prayoridad)
draft_reply(ticket_id, reply_text)
i-escalate_to_human(ticket_id, dahilan)

Pansinin kung ano ang kulang: walang tool na "refund customer", "close account", o "send final reply". Masyadong mapanganib ang mga aksyon na iyon para sa unang bersyon.

Halimbawang tagubilin

Ikaw ay isang support triage agent para sa isang produktong SaaS.

Ang iyong trabaho ay uriin ang mga papasok na tiket, tipunin lamang ang kontekstong kinakailangan, bumuo ng isang iminungkahing tugon, at magpasya kung dapat bang i-eskala ang tiket.

Mga Panuntunan:

Huwag magpadala ng mga tugon nang direkta sa mga customer.

Gamitin ang help center bago sumagot sa mga tanong tungkol sa produkto.

Suriin ang katayuan ng customer bago sumagot sa mga tanong tungkol sa pagsingil, plano, o pag-access.

Kung babanggitin ng customer ang mga legal na banta, pagkawala ng data, mga isyu sa seguridad, pagkabigo ng pagbabayad, pagkansela ng account, o galit na pananalita, idulog ito sa isang tao.

Kung ang sagot ay hindi sinusuportahan ng nakuhang nilalaman ng help center o data ng account, sabihin kung ano ang kulang at i-escalate ito.

Huminto pagkatapos ng maximum na 6 na pagtawag ng tool.

Ang isang tiket ay "tapos na" lamang kapag mayroon itong kategorya, prayoridad, buod ng ebidensya, draft na tugon, at alinman sa "kailangan ng pag-apruba ng tao" o "itinaas".

Paano ito subukan

Magsimula sa 30 test ticket bago ito ikonekta sa mga live user:

10 normal na tiket, tulad ng pag-reset ng password, mga limitasyon sa plano, at mga pangunahing tanong na "paano ko gagawin?"
5 tiket sa pagsingil
5 ulat ng bug
5 malabong tiket na may nawawalang impormasyon
5 mapanganib na tiket, tulad ng mga alalahanin sa seguridad, mga kahilingan sa refund, at mga galit na reklamo

Para sa bawat tiket, puntos:

Napili ba nito ang tamang kategorya?
Gumamit ba ito ng tamang kagamitan bago sumagot?
Naiwasan ba nito ang mga hindi sinusuportahang pahayag?
Pinalala ba nito ang mga mapanganib na tiket?
Kinailangan ba ng matinding pag-edit ang draft?

Sapat na ang isang simpleng spreadsheet para sa pagpasa/pagbagsak sa simula. Huwag palakihin nang sobra ang sistema ng pagsusuri bago mo pa malaman kung nakapaghahatid ba ng halaga ang ahente.

Resulta

Ilustratibong resulta: Batay sa pag-timing ng 30 sample ticket bago at pagkatapos gamitin ang workflow na ito, maaaring masukat ng isang support lead ang mga sumusunod:

Ang karaniwang oras ng unang triage ay nabawasan mula 6 na minuto bawat tiket patungong 90 segundo
30 tiket ang nasuri sa loob ng 45 minuto sa halip na 3 oras
27 sa 30 tiket ang nailagay sa tamang kategorya
5 sa 5 mapanganib na tiket ang naitaas nang tama
0 tugon ng customer ang ipinadala nang walang pag-apruba ng tao

Ang mga numerong ito ay isang halimbawang pagtatantya, hindi isang napatunayang benchmark. Madaling ulitin ang pagsukat: mano-manong orasan ang parehong batch ng mga test ticket, pagkatapos ay patakbuhin ang mga ito sa pamamagitan ng ahente at ihambing ang katumpakan ng kategorya, katumpakan ng escalation, at oras ng pag-eedit.

Ano ang maaaring magkamali

Maaari pa ring mabigo ang ahente sa mga normal na paraan.

Maaaring uriin nito ang isang bigo ngunit simpleng customer bilang "urgent" dahil parang galit ang dating ng pananalita. Maaaring magsulat ito ng isang kumpiyansang sagot mula sa isang lumang artikulo ng tulong. Maaaring patuloy itong maghanap kung kailan dapat i-email ang tamang hakbang. Maaari nitong ilantad ang napakaraming detalye ng account sa isang draft ng tugon.

Ang solusyon ay hindi ang "magsulat ng mas mahusay na prompt" at umasa. Magdagdag ng mga mahigpit na limitasyon:

Mag-escalate kapag may lumabas na pananalita sa pagsingil, seguridad, legal, o pagkansela
Humingi ng mga sitasyon mula sa mga artikulo ng internal help sa buod ng ebidensya
Panatilihin ang "ipadala ang tugon" sa likod ng pag-apruba ng tao
I-log ang bawat tawag sa tool at pangwakas na draft
Patakbuhin muli ang 30-ticket test suite pagkatapos ng bawat prompt, tool, o pagbabago sa patakaran

Praktikal na takeaway

Hindi kailangan ng isang mahalagang ahente ng dramatikong awtonomiya. Sa halimbawang ito, ang halaga ay nagmumula sa isang kontroladong loop: basahin ang ticket, kunin ang tamang konteksto, uriin ito, i-draft ang isang tugon, at huminto para sa pagsusuri. Mas madaling pagkatiwalaan, subukan, at pagbutihin iyon kaysa sa isang ahente na sumusubok na "hawakan ang suporta" gamit lamang ang isang malaking prompt.

Mga Madalas Itanong

Ano ang isang ahente ng AI, sa simpleng pananalita?

Ang isang AI agent ay karaniwang isang loop na umuulit: kumukuha ng input, nagpapasya sa susunod na hakbang, gumagamit ng tool, binabasa ang resulta, at inuulit hanggang sa matapos. Ang bahaging "agent" ay nagmumula sa pagkilos at pagmamasid, hindi lamang pakikipag-chat. Maraming ahente ang smart automation lamang na may access sa tool, habang ang iba ay kumikilos na parang isang junior operator na maaaring makabawi mula sa mga error.

Kailan ako dapat bumuo ng isang AI agent sa halip na gumamit lamang ng isang prompt?

Bumuo ng ahente kapag ang trabaho ay maraming hakbang, nagbabago batay sa mga intermediate na resulta, at nangangailangan ng maaasahang paggamit ng mga tool (mga API, database, ticketing, pagpapatupad ng code). Kapaki-pakinabang din ang mga ahente kapag gusto mo ng mga mauulit na resulta na may mga guardrail at isang paraan upang suriin na "tapos na." Kung gumagana ang isang simpleng prompt-response, ang isang ahente ay karaniwang hindi kinakailangang overhead at mga karagdagang failure mode.

Paano ako bubuo ng isang AI agent na hindi natigil sa mga loop?

Gumamit ng mga kondisyon ng hard stop: max steps, max tool calls, at clear completion checks. Magdagdag ng mga nakabalangkas na tool schemas, timeouts, at mga retries na hindi na uulitin magpakailanman. I-log ang mga desisyon at tool output para makita mo kung saan ito nadidiskaril. Ang isang karaniwang safety valve ay ang escalation: kung ang agent ay hindi sigurado o umuulit ng mga error, dapat itong humingi ng tulong sa halip na mag-improvise.

Ano ang minimum na arkitektura para sa Paano Gumawa ng AI Agent?

Sa pinakamababa, kailangan mo ng isang controller loop na magbibigay sa modelo ng layunin at konteksto, hihingi ng susunod na aksyon, magpapatupad ng tool kung hihilingin, magdaragdag ng obserbasyon, at uulitin ito. Kailangan mo rin ng mga tool na may mahigpit na input/output shapes at isang "tapos na" check. Kahit ang isang roll-your-own loop ay maaaring gumana nang maayos kung pananatilihin mong malinis ang estado at ipapatupad ang mga step limit.

Paano ko dapat idisenyo ang tool calling upang ito ay maaasahan sa produksyon?

Panatilihing makitid, naka-type, may pahintulot, at napatunayan ang mga tool—iwasan ang isang generic na tool na "do_anything". Mas gusto ang mga mahigpit na schema (tulad ng mga structured output/function calling) para hindi basta-basta maisagawa ng agent ang mga input. Magdagdag ng mga allowlist, limitasyon sa rate, at mga pagsusuri sa pahintulot ng user/org sa tool layer. Idisenyo ang mga tool upang maging ligtas na patakbuhin muli kung posible, gamit ang mga pattern ng idempotency.

Ano ang pinakamahusay na paraan upang magdagdag ng memorya nang hindi pinapalala ang ahente?

Ituring ang memorya bilang dalawang bahagi: panandaliang estado ng pagpapatakbo (mga kamakailang hakbang, kasalukuyang plano, mga limitasyon) at pangmatagalang pagkuha (mga kagustuhan, matatag na panuntunan, mga kaugnay na dokumento). Panatilihing siksik ang panandaliang paggamit ng mga tumatakbong buod, hindi ang buong transcript. Para sa pangmatagalang memorya, ang pagkuha (mga embedding + vector store/RAG pattern) ay karaniwang mas mainam kaysa sa "paglalagay" ng lahat sa konteksto at paglito sa modelo.

Aling padron ng pagpaplano ang dapat kong gamitin: checklist, ReAct, o superbisor-manggagawa?

Mahusay ang isang checklist planner kapag ang mga gawain ay nahuhulaan at gusto mo ng isang bagay na madaling subukan. Mas maganda ang mga ReAct-style loop kapag binago ng mga resulta ng tool ang susunod mong gagawin. Nakakatulong ang mga pattern ng supervisor-worker (tulad ng AutoGen-style role separation) kapag ang mga gawain ay maaaring pagsabayin o makinabang mula sa magkakaibang tungkulin (researcher, coder, QA). Ang plan-then-execute na may kasamang replanning ay isang praktikal na gitnang landas para maiwasan ang matigas ang ulo at masamang plano.

Paano ko gagawing ligtas ang isang ahente kung kaya nitong gumawa ng mga totoong aksyon?

Gumamit ng mga pahintulot na may pinakamababang pribilehiyo at paghigpitan ang mga mapanganib na tool sa likod ng mga mode ng pag-apruba o "dry-run". Magdagdag ng mga badyet at limitasyon: max steps, max spend, at mga limitasyon sa tool call kada minuto. I-redact ang sensitibong data bago mag-log, at ihiwalay ang mga dev mula sa mga production environment. Humingi ng mga uncertainty flag o mga tanong sa paglilinaw kapag ang mga input ay hindi malinaw, sa halip na hayaang palitan ng kumpiyansa ang ebidensya.

Paano ko susubukan at susuriin ang isang AI agent para mapabuti ito sa paglipas ng panahon?

Gumawa ng scenario suite na may mga happy path, edge case, tool failure, malabong request, at mga pagtatangkang mag-prompt-injection (istilong OWASP). Mag-iskor ng mga resulta tulad ng tagumpay ng gawain, oras ng pagkumpleto, pagbawi mula sa mga error sa tool, at mga claim na walang ebidensya. Sa tuwing babaguhin mo ang mga tool schema, prompt, retrieval, o memory formatting, patakbuhin muli ang suite. Kung hindi mo ito masusubukan, hindi mo ito maaasahang maipapadala.

Paano ako magde-deploy ng ahente nang hindi pinalalaki ang latency at mga gastos?

Ang isang karaniwang pattern ay isang stateless controller na may panlabas na state store (DB/Redis), mga serbisyo ng tool sa likod nito, at malakas na logging/monitoring (madalas ay OpenTelemetry). Kontrolin ang mga gastos gamit ang retrieval caching, mga compact state summary, mas maliliit na modelo para sa routing/extraction, at paglilimita sa "malalim na pag-iisip" sa pinakamahirap na mga hakbang. Gumamit ng mga pila para sa mahahabang gawain upang hindi mo mabuksan ang mga web request. Palaging magsama ng kill switch.

Mga Sanggunian

Pambansang Instituto ng mga Pamantayan at Teknolohiya (NIST) - NIST AI RMF 1.0 (pagkakatiwalaan at transparency) - nvlpubs.nist.gov
OpenAI - Mga Nakabalangkas na Output - platform.openai.com
OpenAI - Gabay sa pagtawag ng tungkulin - platform.openai.com
OpenAI - Gabay sa mga limitasyon sa rate - platform.openai.com
OpenAI - Tumatakbo ng API - platform.openai.com
OpenAI - Pagtawag ng tungkulin ng mga katulong - platform.openai.com
LangChain - Mga dokumento ng Ahente (JavaScript) - docs.langchain.com
LangChain - Mga dokumento ng Tools (Python) - docs.langchain.com
LangChain - Pangkalahatang-ideya ng memorya - docs.langchain.com
arXiv - Papel ng ReAct (dahilan + kilos) - arxiv.org
arXiv - Papel ng RAG - arxiv.org
Amazon Web Services (AWS) Builders' Library - Mga timeout, muling pagsubok, at backoff na may jitter - aws.amazon.com
OpenTelemetry - Panimulang aklat sa pag-obserba - opentelemetry.io
Guhit - Mga kahilingang idempotent - docs.stripe.com
Google Cloud - Istratehiya sa pagsubok muli (backoff + jitter) - docs.cloud.google.com
OWASP - Nangungunang 10 para sa Malalaking Aplikasyon ng Modelo ng Wika - owasp.org
OWASP - LLM01 Agarang Pag-iiniksyon - genai.owasp.org
LlamaIndex - Panimula sa RAG - developers.llamaindex.ai
Microsoft - Semantikong Kernel - learn.microsoft.com
Microsoft AutoGen - Balangkas ng multi-agent (dokumentasyon) - microsoft.github.io
CrewAI - Mga konsepto ng mga ahente - docs.crewai.com
Haystack (deepset) - Dokumentasyon ng mga Retriever - docs.haystack.deepset.ai

Hanapin ang Pinakabagong AI sa Opisyal na Tindahan ng AI Assistant

Tungkol sa Amin

Balik sa blog