Ang mundo ng AI ay nagiging 'loopy'

Sa Meta's @Scale conference noong nakaraang Biyernes, may isang taong nagtanong sa audience kay Boris Cherny — ang lumilikha ng Claude Code — kung ang AI loops ay ang susunod na hype cycle o tunay na bagay. Ang kanyang sagot ay agarang: tunay, at kasing-halaga ng pagbabago mula sa hand-written code tungo sa agentic AI. Ang palitan na iyon ay nagbigay ng pangalan sa isang bagay na mga developers sa buong mundo ay tahimik na nag-eexperiment, at ito ay nagbabago kung paano natin dapat isipin kung ano talaga ang kakayahan ng AI systems. Ang mundo ng AI ay nagiging 'loopy', at para sa mga developers na nagbubuo sa Asia, ang pagbabagong ito ay may mga partikular na implikasyon na karapat-dapat na tuklasin.

Ano ang Nangyari

Si Boris Cherny, Head ng Claude Code sa Anthropic, lumitaw sa Meta's @Scale conference at gumawa ng kaso na ang "loops" ay kumakatawan sa susunod na pangunahing pagbabago sa arkitektura ng kung paano gumagana ang AI systems. Ang pag-unlad na kanyang inilalarawan ay karapat-dapat na direktang sitahin: "Dalawang taon na ang nakakaraan, kami ay nagsusulat ng source code nang kamay. Nagsimula kaming mag-transition upang ang mga agents ay magsulat ng code. At ngayon kami ay nag-transition sa punto kung saan ang mga agents ay nag-prompt sa mga agents na pagkatapos ay nagsusulat ng code." Siya ay nag-argue na ang pagtalon mula sa agentic AI tungo sa looping AI ay kasing-halaga ng pagtalon mula sa manual coding tungo sa agents sa unang lugar.

Ano talaga ang hitsura ng isang loop sa pagsasanay? Inilalarawan ni Cherny ang kanyang sariling setup sa usapan: isang agent na patuloy na sumusubaybay para sa mga paraan upang mapabuti ang code architecture, ang iba ay naghahanap ng mga duplicate abstractions na maaaring pagsama-samahin. Parehong nagsusumite ng pull requests tulad ng anumang human contributor. Dahil ang codebase ay palaging nagbabago, hindi kailanman tumitigil ang alinman sa mga agent. Walang finish line — lamang patuloy, background improvement.

Ito ay hindi ganap na bagong teritoryo. Ang recursive loops ay naging staple ng computer science mula pa noong simula — mga function na tumatawag sa kanilang sarili hanggang sa matugunan ang isang kondisyon. Ang pagkakaiba dito ay ang stopping condition ay hindi deterministic. Ang isang sub-agent ay nagpapasya kung kailan na ang loop ay sapat na, hindi isang hard-coded rule. Ang non-determinism na ito ay kung ano ang gumagawa nito na tunay na bagong pakiramdam.

Isang sikat na implementasyon na umiikot na sa mga developer communities ay ang Ralph Loop — pinangalan, nang kahanga-hanga, pagkatapos ng Ralph Wiggum — na gumagana sa pamamagitan ng pagbubuod ng lahat ng nakamit ng modelo hanggang sa ngayon at pagtatanong kung ang layunin ay natugunan na. Ito ay isang simpleng ngunit epektibong paraan upang ihinto ang mga AI models mula sa pag-drift kapag tumatakbo sila sa mahabang panahon, sa esensya ay nag-bounce ng modelo sa pagitan ng aksyon at self-evaluation hanggang sa makumpleto ang gawain.

Mayroon ding koneksyon sa mas malawak na push para sa mas maraming test-time compute — ang ideya na ang mga models ay maaaring makabuo ng mas magandang output sa pamamagitan ng paggugol ng mas maraming oras sa pag-iisip sa halip na simpleng pag-scale ng mga parameter. Ang loops ay umangkop nang maayos sa framework na iyon: sa halip na isang malaking inference pass, makakakuha ka ng patuloy, iterative refinement sa paglipas ng panahon.

Bakit Ito Mahalaga para sa Asia

Ang developer ecosystem ng Asia ay palaging mabilis sa pag-adopt, ngunit ang mga structural conditions dito ay gumagawang partikular na relevant ang looping paradigm. Ang engineering talent sa Southeast Asia, India, at East Asia ay mabilis na lumalaki, ngunit ang senior engineering hours ay nananatiling mahal at bihira kumpara sa sukat ng software na kailangang itayo. Ang isang background agent na patuloy na nag-refactor ng iyong codebase, nakakakuha ng mga duplicate abstractions, at nagsusumite ng PRs nang hindi hinihiling — ito ay hindi isang productivity multiplier, ito ay isang structural change sa kung ano ang maaaring mapanatili ng isang maliit na team.

Isaalang-alang ang isang limang-taong startup sa Jakarta o Ho Chi Minh City na naghahatid ng isang fintech product. Sila ay nakikipag-ugnayan sa isang codebase na lumalaki nang mas mabilis kaysa sa kanilang team ay maaaring suriin ito. Ang technical debt ay nag-accumulate hindi dahil ang sinuman ay walang pag-iingat, kundi dahil simpleng walang sapat na oras. Ang isang persistent refactoring agent na tumatakbo sa background — ang uri na inilalarawan ni Cherny — ay tumutugon sa eksaktong constraint na ito. Ito ay hindi nagpapalit ng mga engineers; ito ay humawak sa kategorya ng trabaho na ang mga engineers ay palaging nag-defer.

Mayroon ding language dimension na mahalaga partikular para sa Asia. Karamihan ng tooling at documentation sa AI agent ecosystem ay English-first. Ang loops, sa kanilang kalikasan, ay mas abstract — sila ay gumagana sa code level, kung saan ang language barriers ay mas kaunti ang halaga. Ang isang agent na nagpapabuti ng iyong TypeScript o Python architecture ay hindi kailangang maunawaan ang Bahasa Indonesia o Mandarin upang gawin ang kanyang trabaho. Ito ay gumagawang mas agad na accessible ang looping agents sa Asian development teams kaysa sa maraming ibang AI capabilities na nakadepende sa nuanced natural language understanding.

Ang Asia tech scene ay naging mas mabilis kaysa sa karamihan upang mag-experiment sa multi-agent architectures, partikular sa enterprise automation. Ang mga kumpanya na nagbubuo sa mga platform tulad ng MonstarX ay nag-iisip na sa mga agents na nakikipag-coordinate sa isa't isa, hindi lamang single-model inference. Ang loop concept ay natural na umaangkop sa mental model na iyon — ito ay mas kaunting conceptual jump para sa mga teams na nagtratrabaho na sa agentic workflows.

Ang panganib, siyempre, ay ang mga loops na tumatakbo nang walang sapat na oversight ay maaaring magdulot ng mga error kasing-dali ng mga improvement. Ang isang agent na mali tungkol sa kung ano ang bumubuo ng isang magandang abstraction ay patuloy na magiging mali, sa sukat, magpakailanman. Ang governance challenge na ito ay tunay, at ito ay isa na ang Asian teams ay kailangang isipin nang maingat habang pinagsasama nila ang mga pattern na ito.

Ano Ang Kahulugan Nito para sa Mga Developer

Kung ikaw ay nagbubuo gamit ang AI ngayon, ang mga loops ay nagbabago ng iyong mental model ng kung ano ang ginagawa ng system. Hindi ka na nagsesend ng prompt at naghihintay para sa response. Ikaw ay nag-configure ng isang persistent process — isa na may mga layunin, gumagawa ng mga desisyon, at gumagawa ng mga output sa patuloy na batayan. Ito ay mas malapit sa pagkuha ng isang contractor kaysa sa pagpapatakbo ng isang query.

Sa praktikal, narito kung ano ang kahulugan nito para sa kung paano ka bumubuo:

• I-scope ang iyong mga agents nang mahigpit. Ang mga agents ni Cherny ay bawat isa ay may isang makitid, malinaw na tinukoy na mandate — isa ay naghahanap ng architecture improvements, ang iba ay para sa mga duplicate abstractions. Hindi nila ginagawa ang lahat. Ang mas mahigpit na scope, ang mas kaunting posibilidad na ang isang loop ay mag-drift sa teritoryo kung saan ito ay nakakasakit.
• Bumuo ng evaluation sa loop. Ang Ralph Loop ay gumagana dahil ito ay pinipilit ang modelo na suriin ang kanyang sariling pag-unlad. Ang anumang loop na iyong pinapatakbo ay dapat may isang evaluation step na built-in — kung ito ay isang sub-agent, isang test suite, o isang human review gate para sa mga PR sa itaas ng isang tiyak na complexity threshold.
• Tratuhin ang loop outputs tulad ng contributor PRs. Ang mga agents ni Cherny ay nagsusumite ng pull requests. Iyon ang tamang abstraction. Huwag mag-auto-merge. Suriin ang loop outputs sa parehong paraan na iyong susuriin ang trabaho ng isang junior developer — na may atensyon sa kung ang pagbabago ay tama, hindi lamang kung ito ay nag-compile.
• Magsimula sa read-only loops. Bago mo hayaang isulat at magsumite ang isang agent, patakbuhin ito sa observation mode. Hayaan itong mag-flag kung ano ang ito ay magbabago nang hindi aktwal na nagbabago ng kahit ano. Ito ay nagbibigay sa iyo ng isang pakiramdam kung ang kanyang judgment ay mapagkakatiwalaan bago mo ibigay ang write access.
• Subaybayan ang drift sa paglipas ng panahon. Ang isang loop na tumatakbo sa loob ng mga araw o linggo ay maaaring mag-accumulate ng mga maliit na error na nag-compound. Mag-set up ng logging na nagbibigay-daan sa iyo na i-audit kung ano ang ginawa ng isang loop, hindi lamang kung ano ang kasalukuyang ginagawa nito.

Ang tooling para dito ay patuloy na umuunlad. Karamihan ng mga developers ngayon ay nag-stitch ng mga loops nang manu-mano — gamit ang orchestration frameworks, custom evaluation scripts, at maraming prompt engineering. Ngunit ang mga primitives ay nagiging mas malinaw, at ang mga platform na sumusuporta sa persistent agent execution na may tamang state management ay magiging significantly mas mahalaga habang kumakalat ang pattern na ito.

Para sa mga teams na gumagamit ng MonstarX, ang looping pattern ay natural na umaangkop sa kung paano ang platform ay nag-handle ng multi-step workflows at agent coordination. Ang kakayahan na mag-configure ng persistent agents na may state management ay nangangahulugan na maaari mong i-build ang mas sophisticated na loop architectures nang hindi kailangang mag-stitch ng maraming tools.