Autonomous AI agent: paano pagtrabahuin ang agent nang ilang oras nang hindi nakakakuha ng basura

Ano ang autonomous AI agent at paano ito naiiba sa karaniwang request

Ang karaniwang pakikipagtrabaho sa agent ay hakbang-hakbang: sumulat kayo ng prompt, gumagawa ang agent ng isang hakbang, tinitingnan ninyo ang resulta at pinagpapasyahan kung ano ang susunod. Ang autonomous AI agent ay tumatakbo sa isang ikot: minsan ninyong inilalarawan kung ano ang itsura ng huling estado, at pagkatapos ay inuulit ng agent ang "gawin — suriin — ayusin" hanggang maabot ang layunin o maubos ang badyet. Pagkatapos ng simula, puwede na kayong umalis.

Mukhang simple ito, pero ang karaniwang unang karanasan ay ganito: umaga ibinigay ang gawain sa agent, at sa gabi ay lumalabas na ilang oras nitong inayos ang bug na naayos na pala, dahil nakalimutan nito ang ginawa nito isang oras na ang nakalipas. Walang nagsabi sa kanya kung kailan titigil at kung kailan tatawag ng tao. Narito kung paano idisenyo ang ikot na hindi hahayaang mangyari iyon.

Mahalagang paalala: hindi pinapalitan ng loop ang harness. Ginagawang maaasahan ng harness ang isang pagtakbo, at ginagawang tuloy-tuloy ng loop ang mga pagtakbo. Ang loop sa ibabaw ng mahinang harness ay mas mabilis lang gumawa ng basura.

Angkop ba ang gawain para sa autonomous agent

Ang unang tanong: may dulo ba ang gawain na kayang suriin ng makina? Ang "lahat ng test sa direktoryong tests/payments ay pumapasa", "lahat ng feature sa listahan ay nasa estadong passing", o "tumaas ang sukatan kumpara sa baseline" ay angkop. Ang "pagbutihin ang code" o "ipagpatuloy ang pagpapaayos ng payments" ay hindi: walang dulo ang ganoong layunin, at iikot ang loop hanggang maubos ang badyet.

Makatutulong na makilala ang apat na uri ng loop:

• Hakbang-hakbang — kayo ang nagta-type ng bawat prompt; ito ang karaniwang interactive na trabaho.
• Ayon sa layunin — kayo ang nagtatakda ng layunin, at ang independent na pagsusuri o badyet ang huminto. Ito ang autonomous agent na tumatakbo nang ilang oras.
• Ayon sa oras — tumatakbo ayon sa iskedyul (halimbawa, umagang pagrepaso ng mga sirang CI build), at kayo ang manu-manong humihinto.
• Ayon sa pangyayari — may panlabas na trigger (bagong issue, sirang deploy), at humihinto kapag tapos na ang pagproseso ng pangyayari o naabot ang limitasyon ng pag-ulit.

Karaniwang pagkakamali ang paghalo ng loop ayon sa oras at loop ayon sa layunin: "bawat 10 minuto, ipagpatuloy ang payments." Sa bawat pagtakbo ng loop ayon sa iskedyul, nagsisimula ang instruksyon mula sa simula at hindi alam kung ano na ang nagawa. Kung may dulo ang gawain, kailangan ang loop ayon sa layunin na may memorya ng progreso.

Hakbang 1. Sandbox: saan puwedeng magkamali ang agent

Ang agent na walang bantay ay gagawa ng mali sa kalaunan: magbubura ng file, susulatan muli ang migration, o magpapatakbo ng mabigat na command. Kaya ang tanong ay hindi "paano siya hindi magkakamali", kundi "paano hindi magkakahalaga ang pagkakamali".

• Hiwalay na working copy. Binibigyan ng git worktree ang agent ng sariling direktoryo at sariling branch sa parehong repositoryo. Hindi nagagalaw ang pangunahing branch, hindi nagkakabanggaan ang maraming agent, at nabubura ang pumalyang pagtakbo sa isang command.
• Container o virtual machine. Kung kailangan ng agent ang buong access sa mga command, patakbuhin ito sa container na walang access sa home directory, mga susi, at production database.
• Test na datos. Lokal na database, sandbox ng mga payment system, at pekeng susi. Walang production secret sa environment ng agent.

# sariling branch at direktoryo para sa autonomous na pagtakbo
git worktree add ../shop-agent -b agent/f03-refunds

# pagkatapos ng pagtakbo: tingnan ang resulta o itapon
git -C ../shop-agent log --oneline main..
git worktree remove ../shop-agent

Hakbang 2. Karapatan: pinakamababa na sapat para sa gawain

Kung mas matagal magtrabaho nang mag-isa ang agent, mas makitid dapat ang karapatan nito. Sa Claude Code, itinatakda ang mga pahintulot sa settings.json (listahan ng allow at deny para sa mga tool at command): tahasang payagan ang kailangan ng gawain, gaya ng pagpapatakbo ng test, linter, at pag-edit ng file sa working copy, at ipagbawal ang mapanganib, gaya ng push sa pangunahing branch, paghawak ng secret, at network command kung hindi kailangan.

Ang mode na isinasagawa ang lahat nang walang kumpirmasyon ay pinapayagan lamang sa nakahiwalay na sandbox, kung saan ang pinakamasamang kalalabasan ay isang itinapon na container. Sa makinang pangtrabaho na may access sa inyong mga susi at repositoryo, hindi ito dapat gawin.

Ang mga pagbabawal na hindi dapat labagin ay gawing mekanismo, hindi teksto lamang. Ang linyang "huwag galawin ang migrations/" sa instruksyon ay hiling lamang; ang hook na humaharang sa pag-edit ng direktoryong iyon, o ang karapatan ng file system, ang tunay na garantiya.

Hakbang 3. Layunin, pagsusuri, paghinto: tatlong linya bago tumakbo

Ang pinakasimpleng gumaganang ikot ay nakasandal sa tatlong bagay, at mas mabuting isulat ang mga ito bago magsimula kaysa habang tumatakbo:

1. Layunin — ang itsura ng huling estado.
2. Beripikasyon — paraang kayang suriin ng makina para malaman kung naabot ang layunin: isang command na nagbabalik ng tagumpay o pagkabigo.
3. Kondisyon ng paghinto — limitasyon ng pagsubok, oras, o pera, na pagkatapos nito ay humihinto ang loop kahit hindi naabot ang layunin.

Maginhawang itago ito sa hiwalay na file ng metodolohiya na tanging tao ang nag-e-edit. Halimbawa para sa payment backend:

# program.md — metodolohiya ng autonomous na pagtakbo

## Layunin
Lahat ng feature sa .agent/feature_list.json ay nasa estadong passing.

## Sukatan
Bilang ng feature sa passing. Tumataas nang tuloy-tuloy. Regression = agarang rollback.

## Mga limitasyon
- Isang feature lamang ang ginagawa sa isang pagkakataon.
- Huwag galawin ang migrations/ at infra/.
- Huwag galawin ang mga dependency nang walang tala sa journal.

## Daloy ng trabaho
1. Kunin ang unang feature na wala pa sa passing.
2. Ipatupad, patakbuhin ang pytest at linter.
3. Kung berde — commit at tala sa .agent/progress.md. Kung pula — ayusin.

## Paghinto at pagtaas sa tao
- 3 bigong pagsubok sa isang feature — markahan bilang blocked, lumipat sa susunod.
- Kapag blocked na ang lahat ng natitira — huminto at sumulat ng ulat.
- Anumang gawaing may kinalaman sa pera ng kliyente, karapatan sa access, o pagbura ng datos — hindi gagawin, kundi itataas sa tao.

Hakbang 4. Ikot ng check-fix na may memorya sa disk

Hindi tumatagal ang context window sa mahabang trabaho: napupuno ito, pinaiikli, at nire-restart ang session. Kaya dapat nasa mga file ang progreso, hindi sa "isip" ng agent: listahan ng gawain na may estado, journal ng nagawa at ng hindi gumana, at kasaysayan ng git.

Magandang modelo ang "ratchet na gumagalaw lamang pasulong", gaya ng proyektong autoresearch ni Andrej Karpathy, kung saan nagpapatakbo ang agent ng daan-daang ML experiment magdamag. Bawat iterasyon: basahin ang metodolohiya, bumuo ng hipotesis, gumawa ng pagbabago, patakbuhin ang eksperimento na may nakapirming badyet ng oras, ihambing sa baseline. Kung gumana, commit; kung hindi, rollback. Itinatala ang resulta sa journal, at sumusunod ang susunod na hipotesis.

Dalawang desisyon mula sa skema na ito ang dapat kunin:

• Nakapirming badyet bawat pagsubok. Nagiging maihahambing ang mga pagsubok, at hindi nauubos ng isang bigong hipotesis ang buong magdamag.
• Sa pangunahing branch, pagpapabuti lamang. Lahat ng hindi gumana ay inirollback, hindi iniwan sa tabi. Ang git log ay nagiging na-verify na journal ng trabaho na madaling basahin sa umaga.

Makikita rin sa skemang ito ang paghihiwalay ng tungkulin ayon sa file: walang nag-e-edit ng imprastraktura at ebalwasyon, ang code ng eksperimento lang ang ina-edit ng agent, at tao lamang ang nag-e-edit ng metodolohiya. Hindi kayang "pagandahin" ng agent ang resulta sa pamamagitan ng pagbabago ng paraan ng pagsukat.

Hakbang 5. Sino ang nagpapasya kung tapos na: hiwalay na evaluator

Kapag walang tao sa loop, ang sariling pagsusuri ng agent ang tanging preno, at hindi ito gumagana. Ang agent na katatapos lang sumulat ng code ay madalas na naniniwalang tama ito: nakikita niya ang sarili niyang pangangatwiran at "alam" niya ang gusto niyang gawin.

Mga panuntunan sa paghihiwalay ng generator at evaluator:

• Hindi ang sessyon na gumawa ng trabaho ang dapat magsuri. Sa Claude Code, maginhawa rito ang mga subagent dahil may sariling context ang bawat isa.
• Malinis na context ang dapat matanggap ng evaluator: ang kinakailangan, ang diff, at ang resulta ng mga pagsubok, at wala sa pangangatwiran ng gumawa.
• Kung posible, ibang modelo ang evaluator, o man lang ibang prompt na may ibang papel.
• Ang hatol ay batay sa rubric, at bawat punto ay tumuturo sa patunay: linya ng test, output ng command, lugar sa diff.

Nananatiling pangunahin ang mga awtomatikong pagsusuri. Ang evaluator ay para sa mga bagay na hindi nahuhuli ng test: hindi tama ang pagkaunawa sa kinakailangan, test na inangkop sa code, o pagbabagong lumampas sa saklaw ng gawain.

Mga kriterya ng paghinto: kailan dapat sumuko ang agent

Ang loop na walang kondisyon ng paghinto ay mauuwi sa walang katapusan; tanong na lang kung kailan. Ang pinakakaunting kailangan ay ang mga sumusunod:

Suriin ang progreso ayon sa nilalaman, hindi ayon sa bilang ng pagsubok: ang "40 iterasyon ang nagawa" ay walang kahulugan, ang "tumaas ang bilang ng berdeng feature mula 5 hanggang 9" ay may kahulugan. Kapag natigil ang gawain, senyales ito na ibigay sa tao, hindi na paikutin muli ang loop.

Mga panganib ng autonomous agent na hindi agad nakikita

Ang mga halatang panganib, gaya ng naburang file at sirang build, ay nasasaklaw na ng sandbox at karapatan. Mas mapanganib ang tahimik na gastos na naiipon sa loob ng ilang linggo:

• Utang sa beripikasyon. "Mukhang maayos" sa halip na "napatunayan ng makina." Ang lunas ay mga kondisyon ng paghinto na kayang suriin ng makina, walang pagbubukod.
• Paghina ng pag-unawa. Unti-unti ninyong nakikilala ang sarili ninyong code. Ang lunas ay ang sapilitang pagbasa ng mga diff: hindi dapat lumampas ang bilis ng loop sa bilis ng inyong pagbasa.
• Cognitive capitulation. Tumitigil kayong magkaroon ng sariling opinyon sa resulta at tinatanggap ang lahat. Makatutulong na tapat na bilangin kung ilang beses ninyong sinabing "titingnan ko mamaya" at hindi naman ninyo tiningnan.
• Pamamaga ng context. Ang mahabang pagtakbo ay nag-iipon ng kasaysayan, kaya lalong magastos at lalong humihina ang bawat susunod na hakbang. Kailangan ang pagpapaikli ng context at panlabas na memorya mula sa unang loop, hindi kapag gulo na ang lahat.

Paano patakbuhin ang unang autonomous loop sa isang gabi

Huwag magsimula sa "hahanapin at gagawin ng agent ang mga gawain mismo." Lumalaki ang autonomiya nang paunti-unti: una, isang gawain na may layunin at kondisyon ng paghinto; pagkatapos, isang awtomasyon ayon sa iskedyul; pagkatapos, magkahiwalay na tagagawa at tagasuri sa nakahiwalay na working copy; at saka lang ang mga loop na sila mismo ang naghahanap ng trabaho at sabay-sabay na tumatakbo.

1. Hanapin ang gawaing ginagawa ninyo nang kamay nang hindi bababa sa dalawang beses sa isang linggo at may nakikitang dulo na kayang suriin.
2. Isulat ang layunin, beripikasyon, at kondisyon ng paghinto: tatlong linya.
3. Gumawa ng hiwalay na worktree at itakda ang karapatan: pinapayagan ang test at pag-edit ng file, hindi ang push at mga secret.
4. Gumawa ng file ng progreso at hilingin sa agent na i-update ito pagkatapos ng bawat iterasyon.
5. Paghiwalayin ang mga papel: isinusulat ng tagagawa, sinusuri ng tagasuri sa hiwalay na context ang diff.
6. Maglagay ng pangkalahatang limitasyon at unang beses na tingnan ang resulta pagkalipas ng isang oras, hindi kinaumagahan.

Buod

Ang autonomous AI agent ay kasing-maaasahan lamang ng mga hangganan nito: sandbox kung saan walang halaga ang pagkakamali, pinakamababang karapatan, layuning kayang suriin ng makina, memorya sa disk, hiwalay na evaluator, at mahigpit na kondisyon ng paghinto na may pagtaas sa tao. Kung wala ito, ang mahabang pagtakbo ay hindi pagtitipid ng oras kundi naantalang paglilinis ng gulo. Paano bumuo ng ganitong loop sa isang buong proyekto, mula sa program.md hanggang sa hiwalay na evaluator, ay tinatalakay nang praktikal sa kursong harness engineering.