Ang ahenteng imprastraktura at ang bagong backend

Madalas nating pinag-uusapan ang mga ahenteng balangkas. LangGraph, CrewAI, AutoGen, iba't ibang SDK, loop, tool calling, memory, planner, kritiko, superbisor. Lahat ng kapaki-pakinabang na salita, para sa kabutihan. Ngunit habang tinitingnan ko ang mga ahente na aktwal na ginamit, mas tila sa akin na ang kawili-wiling bahagi ay lumipat sa ibaba ng antas ng balangkas.

Ang tanong ay hindi na lang: aling library ang ginagamit ko para makapag-isip ng isang step model?

Ang totoong tanong ay: saan nakatira ang ahente na ito kapag tumigil siya sa pagiging demo?

Dahil ang isang seryosong ahente ay hindi isang function na tumatawag sa isang modelo at nagbabalik ng text. Ito ay isang maliit na ipinamamahaging sistema. Dapat itong basahin ang konteksto, gumamit ng mga tool, magsagawa ng code, pindutin ang mga file, tandaan ang mga desisyon, humingi ng pahintulot, mabigo nang maayos, mag-restart, mag-iwan ng mga log, hindi masunog ang badyet at hindi maging bulldozer sa loob ng imbakan ng produksyon.

Ang balangkas ay ang manibela. Ang imprastraktura ay ang kalsada, ang preno, ang garahe, ang insurance at ang taong nakakaalam kung nasaan ang mga susi.

Dahil maraming pinag-uusapan ngayon

Noong 2023 at 2024 ang pag-uusap ay napaka-model-centric. Aling LLM? Magkano ang konteksto? Magkano ang halaga nito? Gaano siya kagaling sa programming?

Sa 2025 at 2026 ang pag-uusap ay lumipat. Ang mga modelo ay sapat na mahusay upang gumawa ng tunay na trabaho, ngunit iyon ang dahilan kung bakit ang mga boring bit ay nagiging nakikita: runtime, seguridad, connectors, pagkakakilanlan, observability, code execution, deployment, rollback.

Ito ang natural na paglipat mula sa mahika patungo sa engineering.

Kapag kailangan lang ng isang ahente na bumuo ng tugon, sapat na ang isang chat. Kapag kailangan mong magbukas ng pull request, mag-query ng database, tumawag ng CRM, magsimula ng trabaho, mag-navigate sa isang site, magbasa ng Slack, mag-compile ng code at mag-update ng dokumento, kailangan mo ng operating system sa paligid nito.

Hindi sa literal na kahulugan. Sa kahulugan ng organisasyon.

Ang unang piraso: isang runtime kung saan maaaring tumagal ang ahente

Ang isang ahente ay madalas na gumagana sa mga hakbang. Tingnan ang estado, pumili ng aksyon, gumamit ng tool, obserbahan ang resulta, i-update ang plano, ulitin.

Kung ang loop na ito ay nabubuhay sa loob ng isang kahilingan sa HTTP, agad kang magkakaroon ng problema. Ang ilang mga aksyon ay mabagal. Ang ilan ay naghihintay ng input ng tao. Ang ilan ay nabigo at kailangang subukang muli. Ang ilan ay dapat makaligtas sa isang deployment o timeout.

Dito pumapasok ang matibay na daloy ng trabaho, pila, background ng trabaho at state machine. Hindi sila kaakit-akit, ngunit ang mga ito ang pagkakaiba sa pagitan ng isang ahente na mukhang matalino sa demo at isa na maaari mong iwanang nagtatrabaho habang nagtitinda ka ng kape.

Para sa akin ang agentic runtime ay dapat sumagot ng mga konkretong tanong:

• saan ko ise-save ang estado sa pagitan ng isang hakbang at isa pa?
• ano ang mangyayari kung ang proseso ay namatay sa kalagitnaan?
• maaari ba akong mag-pause at humingi ng pag-apruba?
• maaari ko bang i-replay ang isang run para maunawaan kung bakit niya ginawa iyon?
• maaari ko bang limitahan ang tagal, memorya, mga tool at gastos?

Sinisikap ng Vercel ang harap na ito gamit ang mga AI SDK, function, workflow at tool para sa pagbuo ng mga ahente sa loob ng mga web application. Ngunit ang punto ay hindi lamang Vercel. Ang punto ay ang ahente ay nangangailangan ng isang operational home, hindi isang solong endpoint.

Ang pangalawang piraso: sandbox, dahil ang ahente ay dapat na madumi nang hindi nabasag

Sa sandaling magsulat ng code o magsagawa ng mga command ang isang ahente, kailangan ang sandbox.

Tila isang teknikal na salita, ngunit ang ideya ay domestic: bigyan mo siya ng isang workbench. Maaari itong magbukas ng mga file, mag-install ng mga dependency, magpatakbo ng mga pagsubok, gumawa ng mga eksperimento, bumuo ng output. Kung siya ay nagkakamali, ikaw ay naglalaman ng pinsala. Kung ito ay gumagana, i-promote ang resulta.

Ang isang ahente ng sandbox ay dapat magkaroon ng ilang mga katangian:

• nakahiwalay na filesystem;
• Mga limitasyon ng CPU, memorya at oras;
• kinokontrol na network;
• mga lihim na naka-mount lamang kapag kinakailangan;
• kumpletong mga tala;
• posibilidad na mag-export ng mga artifact;
• malinis na pag-reset sa pagitan ng mga pagtakbo, kung kinakailangan.

Ang Vercel Sandbox ay eksaktong papunta sa direksyong ito: mga nakahiwalay na kapaligiran upang magpatakbo ng code, mag-install ng mga dependency, magtrabaho kasama ang mga file at gumawa ng mga artifact nang hindi pinapatakbo ang lahat sa pangunahing runtime ng application.

Ang bagay na ito ay mas mahalaga kaysa sa tila. Maraming mga ahenteng prototype ang direktang tumalon mula sa modelo patungo sa tunay na sistema. Ang modelo ay maaaring tumawag sa tool. Ang mga tool ay maaaring gumawa ng mga bagay. Mukhang elegante ang lahat hanggang sa unang maling utos, ang unang dependency na naka-install sa maling lugar, ang unang token na nagtatapos sa isang log.

Ang sandbox ay ang pang-adultong paraan ng pagsasabi: sige, ngunit dito.

Ang ikatlong piraso: MCP at ang problema sa connector

Ang Model Context Protocol ay naging isa sa mga pinakakawili-wiling bahagi ng ecosystem dahil sinusubukan nitong i-standardize ang isang bagay na kung hindi man ay mabilis na nagiging hindi mapamahalaan: kung paano natuklasan at ginagamit ng isang modelo ang mga panlabas na tool.

Kung walang pamantayan, ang bawat pagsasama ay isang maliit na isla. Isang connector para sa GitHub na ginawa sa isang paraan, isa para sa Slack tapos isa pa, isa para sa mga database na may iba't ibang semantics, isa para sa browser automation na mukhang wala.

Ang MCP ay nagmumungkahi ng isang karaniwang wika sa pagitan ng kliyente at server: mga tool, mapagkukunan, prompt, awtorisasyon, transportasyon, pagtuklas. Hindi nito mahiwagang nilulutas ang pamamahala at seguridad, ngunit nagbibigay ito ng grammar.

At mahalaga ang grammar. Kapag ang isang ahente ay maaaring kumonekta sa maraming mga tool, ang tanong ay hindi lamang "kaya ba niya ito?". Ang problema ay "naiintindihan ba niya kung ano ang maaari niyang gawin, sa anong mga limitasyon, sa ngalan ng kanino, at nag-iiwan ng kung ano ang bakas?".

Para sa akin ang MCP ay hindi hype dahil ito ay "gumagawa ng tool calling". Nagawa na namin yun. Ito ay hype dahil inililipat nito ang center of gravity mula sa solong pagsasama tungo sa operational catalog ng mga tool.

Sa isang mahusay na arkitektura ng ahente, ang MCP ay nagiging isang uri ng patch panel:

• GitHub para sa code at mga isyu;
• Slack para sa konteksto ng pakikipag-usap;
• Linear o Jira para sa nakaplanong gawain;
• read-only na database para sa analytics;
• browser o scraper na kinokontrol para sa mga panlabas na site;
• imbakan ng dokumento;
• nakahiwalay na mga kapaligiran sa pagpapatupad;
• mga panloob na sistema na nakalantad na may mahigpit na pahintulot.

Ang nakakalito na bahagi ay ang isang walang patakaran na katalogo ng tool ay isang mas eleganteng paraan lamang upang lumikha ng kaguluhan.

Ang ikaapat na piraso: pagkakakilanlan at mga pahintulot

Ito ang lugar kung saan maraming demo ang pumikit.

Ang isang ahente ay kumikilos sa ngalan ng isang tao. Kaya dapat malinaw kung sino ang paksa ng aksyon.

Gumagamit ba ito ng mga pahintulot ng user? Ng isang account ng serbisyo? Ng isang workspace? Mayroon ka bang pansamantala o permanenteng pag-access? Maaari mo bang basahin ang lahat o ilang mapagkukunan lamang? Marunong ka bang magsulat? Pwede mo bang kanselahin? Makakatext ba siya ng mga totoong tao?

Kung hindi mo masasagot nang maayos ang mga tanong na ito, maaga o huli ay gagawa ka ng isang katulong na may mga susi ng bahay at walang alaala kung sino ang nagbigay sa kanya.

Ang panuntunan ng hinlalaki na gusto ko ay ito: ang ahente ay dapat na magagawang mas mababa kaysa sa tao, hindi higit sa tao. At kapag kailangan niyang gumawa ng isang bagay na mas mapanganib, kailangan niyang huminto at magtanong.

Ang ibig sabihin nito ay OAuth, token scoped, secret management, audit log, tool policy, allowlist, approval step. Hindi masyadong romantikong bagay. Mga kinakailangang bagay.

Ang ikalimang piraso: memorya at konteksto, ngunit walang naiipon na basura

Ang mga ahente ay nangangailangan ng memorya, ngunit ang memorya ay mapanganib kapag ito ay naging isang attic.

Mayroong hindi bababa sa tatlong uri ng memorya:

• run memory: kung ano ang nangyari sa pagpapatupad na ito;
• memorya ng proyekto: mga kombensiyon, mga desisyon, mga hadlang;
• memorya ng personal o koponan: mga kagustuhan, tono, mga ritwal, mga proseso.

Ang paglalagay ng lahat sa prompt ay ang shortcut. Gumagana ito hanggang sa hindi na ito gumana. Ang kapaki-pakinabang na memorya ay dapat alagaan: na-index, na-update, nag-expire, na-verify, ginawang citable.

Ang ahente na hindi nakakaalala ay mas masahol pa kaysa sa isang ahente na hindi nakakaalala. Dahil may kumpiyansa siyang nagsasalita.

Samakatuwid ang imprastraktura ay dapat magsama ng pagkuha, mga file ng pagtuturo, base ng kaalaman, pag-embed kung kinakailangan, ngunit din ng paglilinis. Kailangan natin ng kultura ng memorya: kung ano ang pumapasok, kung sino ang nag-aproba nito, kapag ito ay nabubulok, paano ko ito itatama.

Ang ikaanim na piraso: observability, eval at replay

Kung nagkamali ang isang ahente, hindi sapat ang log na "tinatawag na modelo."

Gusto mong makita ang ruta. Anong konteksto ang natanggap niya? Anong mga tool ang magagamit? Aling tool ang pinili mo? Sa anong mga argumento? Anong tugon ang nakuha mo? Magkano ang halaga nito? Saan ito natigil? May inaprubahan ba ang tao? Error ba ang modelo ng error, tool, prompt, data o pahintulot?

Dito ang mga ahente ay mas katulad ng mga distributed system kaysa sa mga chatbot.

Kailangan mo ng mga nababasang bakas, hindi lang mga text log. Kailangan mong makapag-replay ng isang run. Kinakailangang ihambing ang dalawang bersyon ng parehong ahente sa mga kilalang gawain. Kailangan nating sukatin ang mga regression: hindi lamang ito "nakakasagot ng mas mahusay", ngunit ito ay "nagsasara ng tamang tiket nang hindi hinahawakan ang mga hindi hinihinging file".

Ang mga ahenteng eval ay mas mahirap kaysa sa mga text eval dahil kasama nila ang mga aksyon. Hindi sapat na ihambing ang isang inaasahang string. Kailangan mong tingnan ang mga sequence, side effect, kalidad ng artefact, oras, gastos, bilang ng mga interbensyon ng tao.

Ang nakakatawa, palagi kaming bumabalik doon: software engineering. Mga pagsubok, kapaligiran, bakas, rollback. Maliban na ang code ngayon ay nagpapasya din kung ano ang susunod na gagawin.

Ang ikapitong piraso: mga interface ng tao

Ang ahente ay hindi kailangang mabuhay lamang sa isang chat.

Ang ilang mga ahente ay nangangailangan ng isang board. Ang iba ay isang page na may status at log. Iba sa isang "approve" na button. Higit pang mga inline na komento. Ang iba pa sa isang CLI.

Ang UI ay nagbabago ng gawi. Kung ang tanging paraan upang makontrol ang isang ahente ay ang magsulat ng isang mahabang mensahe, ang gumagamit ay magbibigay sa ahente ng hindi malinaw na mga tagubilin. Kung, gayunpaman, nakikita niya ang plano, pagkakaiba, pinagmumulan, mga panganib at susunod na aksyon, maaari siyang makialam nang eksakto.

Kasama sa isang disenteng imprastraktura ng ahente ang mga control surface:

• kasalukuyang katayuan;
• nae-edit na plano;
• ginawang mga artifact;
• pagkakaiba;
• mga kahilingan sa pag-apruba;
• kronolohiya;
• pindutan ng stop;
• pindutan ng muling subukan;
• nakikitang mga pahintulot.

Parang walang kuwenta, pero hindi. Ang pagkakaiba sa pagitan ng "katakut-takot na AI" at "maaasahang katulong" ay madalas na ang huli ay nagpapakita sa iyo kung saan mayroon itong mga kamay.

Ang mental stack

Kung iguguhit ko ito ngayon, ang pinakamababang stack ng ahente ay ito:

1. Modelo: pangangatwiran, henerasyon, tool calling, multimodal kung kinakailangan.
2. Orkestrasyon: loop, hakbang, tagaplano, patakaran, human-in-the-loop.
3. Matibay na runtime: workflow, queue, retry, pause, resume.
4. Sandbox: code execution, nakahiwalay na file system, mga limitasyon, artifact.
5. Tool layer: MCP, internal API, browser, database, repository.
6. Layer ng pagkakakilanlan: OAuth, saklaw, lihim, audit, patakaran.
7. Layer ng memorya: konteksto ng proyekto, pagkuha, mga tagubilin, pag-expire.
8. Pagmamasid: mga sukatan ng pagsubaybay, pag-replay, eval, gastos at kalidad.
9. Ibabaw ng produkto: makipag-chat kapag sapat na, dashboard kung kinakailangan, suriin kung ito ay mahalaga.

Ang balangkas ng ahente ay pangunahing sumasaklaw sa mga punto 2 at isang piraso ng punto 1. Ang natitira ay ang tunay na gawain.

Ano ang gagawin ko sa pagsasanay

Kung sinabi sa akin ng isang team na "gusto namin ng mga ahente sa produksyon," hindi ako magsisimula sa sampung ahente.

Magsisimula ako sa isang maliit, paulit-ulit at nakikitang daloy ng trabaho. Halimbawa: bukas na maintenance PR, i-update ang dokumentasyon mula sa mga saradong isyu, maghanda ng lingguhang pagsusuri, triage ang mga duplicate na bug, bumuo ng mga pagsubok para sa mga apektadong file.

Pagkatapos ay magtatakda ako ng napakalinaw na mga limitasyon:

• walang pagsusulat nang walang mga sanga o sandbox;
• walang mga lihim sa prompt;
• mga tool sa allowlist;
• pag-apruba ng tao para sa mga panlabas na aksyon;
• ipinag-uutos na log at bakas;
• badyet sa bawat pagtakbo;
• ang output ay palaging nasusuri.

Saka lang ako magpapalawak.

Ang mga ahente ay hindi nabigo dahil lamang sa mga modelo ay nagkakamali. Nabigo ang mga ito dahil inilalagay namin sila sa mga hindi malinaw na kapaligiran, na may nakalilitong mga pahintulot at mga inaasahan sa teatro.

Ang aking pagbabasa

Ang ahenteng imprastraktura ay nakakainip sa pinakamahusay na paraan.

Hindi yung part na nagpapalakpak ka sa demo. Ito ang bahagi na nagbibigay-daan sa iyong aktwal na gamitin ang demo sa Lunes ng umaga, na may mga totoong tao, totoong data, at totoong mga kahihinatnan.

Ang kinabukasan ng mga ahente ay hindi lamang magpapasya kung sino ang may pinakamahusay na huwaran. Ito ay pagpapasya ng sinumang gagawa ng pinakamagandang lugar kung saan siya mapapatrabaho: nakahiwalay kapag siya ay nag-eeksperimento, konektado kapag kinakailangan, palaging napapansin, may pahintulot na may pamantayan at sapat na mapagkumbaba upang huminto kapag hindi niya alam.

Doon huminto sa pagiging laruan ang mga ahente at naging imprastraktura.

Mga Pinagmulan

• Vercel: Paano bumuo ng mga ahente ng AI gamit ang Vercel at ang AI SDK
• Vercel Docs: Sandbox
• Vercel Docs: Paggawa gamit ang Sandbox
• Vercel Docs: MCP
• Model Context Protocol: Specification
• OpenAI: Mga bagong tool para sa mga ahente ng gusali
• Cloudflare Blog: Mga Ahente sa Cloudflare