Paano Matuto ng AI Agents Mula sa Simula

Ang landas sa anim na yugto

Para matutuhan ang AI agents mula sa simula, pagdaanan ang anim na yugto ayon sa pagkakasunod-sunod: mga konsepto, unang loop, tools, memory, disenyo ng loop, at safety. Sa bawat yugto, may isang bagay na ikaw mismo ang bubuo. Ang paglaktaw sa mga naunang yugto ang pinakakaraniwang dahilan kung bakit nahihinto ang mga tao, dahil itinatago ng framework ang mismong bahaging kailangan mong makita.

Ang AI agent ay isang loop sa paligid ng language model na pinapayagang tumawag sa tools. Iyan ang buong paksa. Ang lahat ng kasunod ay mga detalye tungkol sa inilalagay sa loop, sa mga bahaging maaaring galawin ng tools, at sa paraan ng paghinto sa loop kapag nagkamali ito. Kung maipapaliwanag mo ang loop sa ibang tao, natutuhan mo na ang konsepto. Kung frameworks lamang ang matutukoy mo, hindi mo pa ito natutuhan.

Ipinapalagay ng plano sa ibaba na natututo ka sa pamamagitan ng pagbuo. Basahin ang isang yugto, buuin ang maliit na bagay, sadyang sirain ito, saka magpatuloy. Ang yugtong nabasa mo lamang ay yugtong hindi mo pa talaga nagagawa.

Ang aktuwal na kailangan mo bago ang stage 1

Maikli ang totoong listahan ng mga prerequisite, at mas maikli ito kaysa sa ipinahihiwatig ng karamihan sa mga course page.

• Marunong kang bumasa at sumulat ng Python o TypeScript sa antas ng script na limampung linya.
• Komportable kang gumamit ng Linux shell: mag-install ng package, mag-edit ng file, at magbasa ng log.
• May API key ka para sa isang hosted model, o may machine kang kayang magpatakbo ng local model.

Iyon lang ang buong listahan. Hindi mo kailangan ng teorya sa machine learning, at hindi mo kailangang nakapagsanay na ng model. Walang gradients o training data sa agent work. Mahalaga lamang ang graphics card kung magpapasya kang patakbuhin mismo ang model, na hiwalay na kasanayang maaari mong matutuhan sa ibang pagkakataon mula sa pag-host ng Ollama sa VPS para mag-self-host ng LLM.

Ang madalas minamaliit ng mga tao ay ang bahagi tungkol sa shell. Nabibigo ang mga agent dahil sa permissions, paths, environment variables, at mga process na tahimik na namamatay. Kung napapapikit ka sa terminal kapag nakakakita ka ng stack trace tungkol sa PATH o file mode, maglaan muna ng isang weekend para sa mga pangunahing kaalaman sa Linux. Makakatipid ito sa iyo ng isang buwan sa hinaharap.

Yugto 1: ano ang isang agent, at ano ang hindi nito

Magsimula sa isang API call at walang loop. Magpadala ng prompt, i-print ang reply, at tingnan ang bilang ng mga token sa response. Nauunawaan mo na ngayon ang yunit ng gastos at ang yunit ng latency.

Pagkatapos, pag-aralan ang paggamit ng tool. Ito ang tanging tunay na bagong ideya sa buong larangan. Inilalarawan mo sa model ang isang function gamit ang pangalan, paglalarawan, at JSON (JavaScript object notation) schema para sa mga input nito. Walang pinapatakbo ang model. Nagbabalik ito ng structured request: tawagin ang run_command gamit ang mga argumentong ito. Pinapatakbo ng iyong code ang function, ipinapadala ang output pabalik bilang isang message, at muling tinatanong ang model. Ang model ay planner na nagbabasa ng text at nagsusulat ng text. Ang iyong code ang may kakayahang magsagawa ng mga aksiyon.

Nagtatapos ang chatbot pagkatapos ng isang reply. Inuulit ng agent ang exchange na iyon hanggang sa tumigil ang model sa paghingi ng mga tool. Iyon ang buong pagkakaiba, at iyon din ang dahilan kung bakit naiiba ang mga failure mode. Minsan nagbibigay ng maling sagot ang chatbot. Ang agent naman ay maaaring kumilos batay sa maling sagot nang ilang ulit bago ito mapansin.

Yugto 2: Isulat mismo ang loop, isang beses

Huwag magsimula sa framework. Sumulat ng humigit-kumulang tatlumpung linya ng Python para ikaw ang magtakda ng anyo nito.

sudo apt update && sudo apt install -y python3-venv
python3 -m venv ~/agent
source ~/agent/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY=your-key-here

import subprocess
import anthropic

client = anthropic.Anthropic()

tools = [{
    "name": "run_command",
    "description": "Run a read only shell command and return its output.",
    "input_schema": {
        "type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"],
    },
}]

messages = [{"role": "user", "content": "How much disk space is free here?"}]

while True:
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        break
    messages.append({"role": "assistant", "content": response.content})
    results = []
    for block in response.content:
        if block.type == "tool_use":
            done = subprocess.run(
                block.input["command"], shell=True,
                capture_output=True, text=True, timeout=10,
            )
            results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": done.stdout or done.stderr,
            })
    messages.append({"role": "user", "content": results})

print(next(b.text for b in response.content if b.type == "text"))

Patakbuhin ito gamit ang python3 agent.py. Sa maayos na run, magpi-print ito ng isang paragraph na naglilista ng iyong mga filesystem at ang libreng espasyo ng mga ito, dahil humingi ang model ng df -h, pinatakbo ito ng iyong code, at ginawang pangungusap ng second pass ang table. Kung walang nai-print, natapos ang loop bago dumating ang text block. Idagdag ang print(response.stop_reason) sa loob ng loop at obserbahan ang pagbabago ng mga value.

Ngayon, sirain ito nang sadya. Burahin ang linyang tool_use_id at basahin ang error, dahil tinatanggihan ng API ang tool result na walang katugmang id, at ito ang pinakakaraniwang bug ng mga beginner. Magtanong ng nangangailangan ng dalawang command at obserbahan ang loop na tumakbo nang dalawang beses. Magtanong ng imposibleng sagutin at obserbahan kung susuko ito o iikot nang walang hanggan.

Isang babala tungkol sa halimbawang ito. Direktang ipinapasa nito ang output ng model sa shell gamit ang shell=True. Katanggap-tanggap ito sa isang scratch machine na maaari mong muling i-build, pero mali ito sa lahat ng iba pang sitwasyon. Inaayos ito ng Stage 6. Mas detalyadong tinatalakay ang mga konsepto sa loop sa pagbuo ng sarili mong AI agent sa isang VPS.

Stage 3: Mga tool na wala pa sa agent

Gumagana ang iyong run_command tool, pero kailangan ng isang tunay na agent ng mga tool na nakakaabot sa labas ng system: isang ticket system, database, o repository. Hindi scalable ang pagsulat ng custom wrapper para sa bawat service at bawat agent.

Ang Model Context Protocol (MCP) ang pamantayang pinagtibay ng industriya para dito. Naglalantad ang isang MCP server ng set ng mga tool sa pamamagitan ng standard transport, at magagamit ito ng anumang MCP-aware agent nang walang custom glue. Isang command lang ang reference filesystem server:

npx -y @modelcontextprotocol/server-filesystem /home/you/projects

Kailangang naka-install ang Node, at ang directory argument lang ang path na maaaring galawin ng server. Ito ang pinasimpleng anyo ng security model: ang server ang nagtatakda ng boundary, hindi ang model. Ituro rito ang isang client, at magkakaroon ang iyong agent ng kakayahang magbasa at magsulat ng mga file na hindi mo kailangang ikaw mismo ang gumawa. Saklaw sa pagpapatakbo ng MCP servers sa isang VPS para sa AI coding agents ang tamang pagpapatakbo ng mga ito, gamit ang service account at ipinaliwanag na mga pagpipilian sa transport.

Ang aral sa stage na ito ay ang tool design ang tunay na gawain. Kapag malabo ang description, manghuhula ang model. Kapag nagbalik ang tool ng apatnapung libong character, masisira ang context window. Ang tool na kayang mag-delete ng mga bagay ay kalaunan talagang magde-delete ng mga bagay.

Stage 4: memorya, na kadalasan ay mga file lang

Dito karaniwang gumagamit ang mga baguhan ng vector database. Huwag muna, kahit sa ngayon.

Walang memorya ang isang agent sa pagitan ng mga call. Ipinapadala mong muli ang buong conversation sa bawat pagkakataon, kaya mas mahal bawat turn sa mahabang session kaysa sa maikling session. Kaya nahahati sa dalawang problema ang memorya. Ang una ay kung ano ang kasya sa context window sa kasalukuyan. Pinamamahalaan mo ito sa pamamagitan ng pagbubuod, pag-alis ng lumang tool output, at pag-cache ng stable prefix ng prompt para maliit na bahagi lang ng presyo ang bayaran mo para rito. Ang ikalawa ay kung ano ang nananatili pagkatapos ng restart. Ito ay storage.

Para sa ikalawang problema, mas mainam para sa halos lahat ng unang project ang isang simpleng markdown file na kayang basahin at sulatan ng agent kaysa sa vector database. Bigyan ito ng isang file, sabihin ang format, at sabihin dito na basahin ang file bago magsimula at i-update ito kapag may natutuhan. Makukuha mo ang karamihan ng pakinabang, at mabubuksan mo ang file para makita kung ano ang pinaniniwalaan ng agent. Gumamit ng embeddings at retrieval kapag hindi na kasya ang mga tala sa context window, at huwag bago nito.

Yugto 5: ang loop ang produkto

Sa puntong ito, makakagawa ka na ng agent na gumagana habang mino-monitor mo ito. Ang layunin sa Yugto 5 ay gumana ito kahit hindi mo ito mino-monitor.

Apat na tanong ang tumutukoy kung ligtas iwanang mag-isa ang isang unattended agent. Ano ang nagti-trigger dito para hindi ito tumakbo nang walang input. Sa anong boundary ito gumagana para manatiling maliit ang epekto ng pagkakamali. Paano ibe-verify ang resulta, dahil palaging pumapasa ang agent na siya mismo ang nagche-check ng sarili nitong trabaho. Anong budget ang magpapahinto rito, batay sa tokens o wall-clock time. Ang maingat na pagdisenyo sa apat na ito ang disiplina na inilalarawan sa loop engineering at kung ano ang saklaw ng depinisyong iyon.

Ang exercise: kunin ang agent mo sa stage 2, bigyan ito ng task na nangangailangan ng apat o limang hakbang, at magdagdag ng hard iteration cap. Pagkatapos, alisin ang cap at obserbahan ang epekto ng walang limitasyong loop sa token bill mo. Gawin ito nang isang beses gamit ang maliit na budget para hindi mo ito aksidenteng magawa gamit ang malaking budget.

Stage 6: kaligtasan, mga lihim, at gastos

Hindi opsyonal ang stage na ito. Huli lamang ito dahil hindi mo mararamdaman ang panganib hangga't wala ka pang nabubuong gumaganang system.

Patakbuhin ang agent gamit ang sarili nitong unprivileged user. Huwag itong patakbuhin bilang root o gamit ang sarili mong account. Sa ganitong paraan, directory ang blast radius sa halip na buong machine. Ilayo ang credentials sa abot ng model. Anumang nasa context window ay maaaring maibalik sa pamamagitan ng tool call. Ang solusyon ay mga short-lived token na may limitadong scope at nakatago sa likod ng helper, gaya ng inilalarawan sa paglalayo ng mga secret sa iyong AI agents. Magtakda ng mahigpit na maximum na gastusin. Sinisingil ng unattended loop ang bawat iteration nang walang nagbabantay. Makikita sa pagkontrol sa gastos ng AI agent sa isang always-on VPS ang mga cap at batching na kailangan para manatiling kontrolado ang gastos.

Kailangang may isang konkretong numero para sa gastos. Noong July 2026, naniningil ang Claude Opus 5 ng $5 bawat million input tokens at $25 bawat million output tokens. Maaaring magpadala ang isang agent na maraming mensahe ng ilang daang libong token sa iisang task habang paulit-ulit nitong ipinapadala ang lumalaking conversation. Mas malaki ang epekto sa kalkulasyong ito ng prompt caching at paggamit ng mas maliit na model para sa mga routine step kaysa sa anumang pagbabago sa prompt.

Dapat ding isama rito ang prompt injection. Kung nagbabasa ang agent ng web page, issue tracker, o inbox, ang sumulat ng text na iyon ay siya ring nagsusulat ng mga instruction para sa agent. Hindi mas matalinong system prompt ang depensa. Ang boundary ang depensa. Hindi makukumbinsi ang agent na mag-delete ng repository kung wala itong kakayahang mag-delete nito.

Aling mapa ang dapat mong sundan?

Pumili ng isang curriculum at tapusin ito sa halip na sumubok ng anim. Ang ai-agents-for-beginners repository ng Microsoft ang pinakakomprehensibong libreng opsyon. Binubuo ito ng labingwalong lesson at umabot na sa mahigit 70,000 stars noong Hulyo 2026. Malinaw itong tumutugma sa mga yugtong nabanggit sa itaas. Kapaki-pakinabang ang mga roundup ng trending agent repository para makita kung ano ang available, pero hindi gaanong kapaki-pakinabang ang mga ito bilang syllabus. Ang listahang inayos ayon sa stars ay batay sa popularity, hindi sa pagkakasunod-sunod ng pagtuturo.

Kapag gusto mo ng totoong project na mapagpapraktisan, coding agent ang pinakamainam na unang target. Agad ang feedback, malinaw ang mga tool, at madaling i-undo ang mga pagkakamali. Ipinapakita ng Pagpapatakbo ng coding AI agent sa isang VPS ang buong proseso mula simula hanggang wakas. Kung mas nais mong pag-aralan ang mga gumaganang system kaysa bumuo mula sa simula, ipinapakita ng paghahambing sa pinakamahuhusay na self-hosted AI agent kung paano nilulutas ng ilang project ang parehong loop sa magkakaibang paraan.

Gaano katagal ito?

Para sa taong marunong nang mag-program, matatapos ang stage 1 at 2 sa loob ng isang gabi. Ang stage 3 ay karaniwang aabutin ng isang weekend. Karamihan ng oras ay mapupunta sa mga paglalarawan ng tool, hindi sa protocol. Ang stage 4 at 5 ay nangangailangan ng ilang linggong aktuwal na paggamit. Malalaman mo lang kung ano ang nakakalimutan ng agent kapag mino-monitor mo itong nakakalimot. Hindi ganap na natatapos ang stage 6, dahil muling nagbubukas ang prosesong ito sa bawat bagong capability na ibinibigay mo.

Sa loob ng 2 buwan ng tuloy-tuloy na pag-aaral tuwing gabi, karamihan ng tao ay makakabuo ng gumagana, may malinaw na limitasyon, at kapaki-pakinabang na agent. Ang mga umaabot ng 1 taon ay karaniwang patuloy na nagbabasa sa halip na bumuo.

FAQ

Kailangan ko bang malaman ang machine learning para makabuo ng AI agent?

Hindi. Ang pagbuo ng agent ay nangangahulugang pagtawag sa isang model sa pamamagitan ng API at pagkonekta ng mga tool request nito sa mga aktuwal na function. Karaniwang application programming ito. Hindi mo kailangang galawin ang training, gradients, o datasets. Ang mga kasanayang tumutukoy kung gagana ang iyong agent ay schema design para sa mga tool, error handling, at Linux permissions. Nagiging mahalaga lamang ang machine learning theory kung magpapatuloy ka sa fine-tuning ng isang model. Ibang gawain iyon at iba rin ang mga kinakailangan.

Dapat ba akong magsimula sa isang framework gaya ng LangChain o CrewAI?

Sumulat muna ng isang raw loop, saka gumamit ng framework. Pinapalitan ng framework ang 30 linya sa stage 2 ng isang configuration object. Maginhawa ito kapag alam mo na kung ano ang pinalitan nito, pero nakalilito bago iyon. Kapag hindi tama ang kilos ng iyong agent, kailangan mong direktang suriin ang message list at mga resulta ng tool. Mas mahirap ito kung hindi mo pa nakita ang mga ito. Pagkatapos mong gumawa ng sarili mong loop, makatutulong ang framework sa pagtitipid ng oras sa halip na itago ang mekanismo.

Magkano ang gastos sa pag-aaral tungkol sa AI agents?

Mas mababa ito kaysa sa inaasahan ng karamihan, kung lalagyan mo ng limitasyon. Sapat na ang isang hosted API key at maliit na VPS para sa lahat ng anim na stage na ito. Ang tunay na panganib ay hindi ang hourly rate. Ito ay ang walang limitasyong loop na naniningil sa bawat iteration habang natutulog ka. Magtakda ng hard spend limit sa iyong API account sa unang araw, magdagdag ng iteration cap sa bawat loop na isusulat mo, at gumamit ng mas murang model para sa mga karaniwang hakbang. Inaalis ng lokal na pagpapatakbo ng model ang token bill, pero kapalit nito ang pangangailangan sa hardware.

Ano ang pagkakaiba ng AI agent at chatbot?

Isang beses sumasagot ang chatbot. Inuulit ng agent ang isang cycle: humihingi ng tool ang model, pinapatakbo ito ng iyong code, ibinabalik ang resulta, at nagpapasya ang model kung ano ang susunod na gagawin. Ang pag-uulit na ito ang nagbibigay-daan sa agent na tapusin ang isang task na maraming hakbang. Ito rin ang dahilan kung bakit nangangailangan ang agents ng mga boundary na hindi kailangan ng chatbots. Ang maling sagot ng chatbot ay isang masamang talata. Ang maling sagot ng agent ay isang masamang talata, kasama ang anumang ginawa nito tungkol dito.