Paano Matututuhan ang AI Agents Mula sa Simula

Ang landasin sa anim na yugto

Upang matutuhan ang AI agents mula sa simula, pag-aralan 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 kang bubuuin gamit ang sarili mong mga kamay. Ang paglaktaw sa mga naunang yugto ang pinakakaraniwang dahilan kung bakit natitigil ang pagkatuto, 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 detalye tungkol sa inilalagay sa loop, sa mga bahaging maaaring ma-access 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 lang ang kaya mong pangalanan, 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, at saka magpatuloy. Ang yugtong nabasa mo lang ay yugtong hindi mo pa nagagawa.

Ang aktuwal na kailangan bago ang stage 1

Maikli ang tapat na listahan ng mga prerequisite, at mas maikli ito kaysa sa iminumungkahi ng karamihan sa mga course page.

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

Iyon lang ang buong listahan. Hindi mo kailangan ng teorya ng machine learning, at hindi mo kailangang nakapagsanay ng model. Walang kinalaman ang 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 isang VPS para mag-self-host ng LLM.

Ang 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 o isinasara ang terminal kapag may stack trace tungkol sa PATH o file mode, maglaan muna ng isang weekend para sa Linux basics. Makakatipid ito ng isang buwan sa susunod.

Stage 1: kung ano ang agent at kung ano ang hindi nito

Magsimula sa isang API call at walang loop. Magpadala ng prompt, i-print ang reply, at tingnan ang token counts sa response. Nauunawaan mo na ngayon ang unit ng cost at ang unit ng latency.

Pagkatapos, pag-aralan ang tool use. Ito ang tanging tunay na bagong ideya sa buong larangan. Ilarawan sa model ang isang function gamit ang pangalan, description, 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 code mo ang function, ipinapadala ang output pabalik bilang message, at muling tinatanong ang model. Ang model ay planner na nagbabasa ng text at nagsusulat ng text. Ang code mo ang may kakayahang magsagawa ng mga aksyon.

Nagtatapos ang chatbot pagkatapos ng isang reply. Inuulit ng agent ang exchange na iyon hanggang sa tumigil ang model sa paghingi ng tools. Iyon ang buong kaibahan, at iyon din ang dahilan kung bakit magkakaiba ang failure modes. Minsan lang nagbibigay ng maling sagot ang chatbot. Ilang beses kumikilos ang agent batay sa maling sagot bago ito mapansin.

Yugto 2: ikaw mismo ang sumulat ng loop, isang beses

Huwag magsimula sa framework. Sumulat ng humigit-kumulang tatlumpung linya ng Python para ikaw mismo ang humubog sa istruktura 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 talata na naglilista sa iyong mga filesystem at sa available nilang space, dahil hiniling ng model ang df -h, pinatakbo ito ng iyong code, at ginawang pangungusap ng second pass ang table na iyon. Kung walang mai-print, natapos ang loop bago dumating ang isang text block. Idagdag ang print(response.stop_reason) sa loob ng loop at tingnan kung paano nagbabago ang mga value.

Sadyain ngayon ang pagkasira nito. 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 isang tanong na nangangailangan ng dalawang command at tingnan kung dalawang beses tatakbo ang loop. Magtanong ng imposibleng bagay at tingnan kung susuko ito o iikot nang walang katapusan.

May isang babala tungkol sa halimbawang ito. Direktang ipinapasa nito ang output ng model sa shell gamit ang shell=True, na katanggap-tanggap sa isang scratch machine na maaari mong i-rebuild ngunit mali sa lahat ng ibang sitwasyon. Tinutugunan ito ng Stage 6. Mas malawak na tinatalakay ang mga konsepto sa ilalim ng loop sa pagbuo ng sarili mong AI agent sa isang VPS.

Yugto 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 kumokonekta sa labas ng machine: ticket system, database, at repository. Hindi scalable ang pagsusulat ng custom wrapper para sa bawat serbisyo at bawat agent.

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

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

Kailangan nito ng naka-install na Node, at ang directory argument lamang ang path na gagalawin ng server. Ito ang pinaikling 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 kahit hindi mo isinulat ang mga iyon. Tinalakay sa pagpapatakbo ng MCP servers sa VPS para sa AI coding agents kung paano ito patakbuhin nang maayos, gamit ang service account at mga ipinaliwanag na transport option.

Ang aral sa yugtong ito ay ang tool design ang tunay na gawain. Kapag malabo ang description, manghuhula ang model. Kapag nagbabalik ang tool ng apatnapung libong character, napupuno nito ng hindi kailangang data ang context window. Kapag may kakayahang mag-delete ang isang tool, darating ang panahong may madi-delete ito.

Yugto 4: memory, na kadalasan ay mga file lang

Karaniwang gumagamit agad dito ang mga beginner ng vector database. Huwag muna, kahit sa ngayon.

Walang memory ang isang agent sa pagitan ng mga call. Ipinapadala mong muli ang buong conversation sa bawat pagkakataon. Dahil dito, mas mataas ang bayad sa bawat turn ng mahabang session kaysa sa maikling session. Kaya nahahati ang memory sa dalawang problema. Ang una ay kung ano ang kasya sa context window sa kasalukuyan. Pinamamahalaan mo ito sa pamamagitan ng pagbuod, pag-trim ng lumang tool output, at pag-cache sa stable prefix ng prompt para maliit na bahagi lang ng presyo ang babayaran mo para rito. Ang ikalawa ay kung ano ang nananatili matapos ang restart. Ito ang storage.

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

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 gawin itong gumana kahit hindi mo ito binabantayan.

Apat na tanong ang tumutukoy kung ligtas iwanang tumakbo nang walang bantay ang isang agent. Ano ang nagti-trigger dito para hindi ito tumakbo nang walang layunin. Sa anong boundary ito gumagana para manatiling maliit ang epekto ng pagkakamali. Paano vine-verify ang resulta, dahil palaging papasa ang agent na siya rin ang nagche-check ng sarili nitong output. Anong budget ang magpapahinto rito, batay man sa tokens o sa aktuwal na elapsed time. Ang maingat na pagdisenyo sa apat na ito ang disiplina na inilalarawan sa loop engineering at saklaw ng depinisyong ito.

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

Yugto 6: kaligtasan, mga lihim, at gastos

Hindi opsyonal ang yugtong 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, upang directory lamang at hindi ang buong machine ang maapektuhan kapag may breach. Ilayo ang credentials sa naaabot ng model, dahil anumang nasa context window ay maaaring maibalik sa output sa pamamagitan ng tool call. Ang tamang paraan ay gumamit ng scoped, short-lived token sa likod ng helper, gaya ng inilalarawan sa pag-iwas na mailantad ang mga lihim sa iyong AI agents. Magtakda ng hard ceiling sa gastos, dahil sisingilin ang bawat iteration ng unattended loop nang walang nagmo-monitor. Ang mga cap at batching na nagpapanatili rito sa kontrol ay nasa pagkontrol sa gastos ng AI agent sa isang always-on VPS.

Mahalagang magkaroon ng isang konkretong numero para sa gastos. Noong July 2026, naniningil ang Claude Opus 5 ng $5 bawat milyong input token at $25 bawat milyong output token. Maaaring magpadala ang isang madaldal na agent ng ilang daang libong token sa isang task habang paulit-ulit nitong ipinapadala ang lumalaking conversation. Malaki ang ibinabago ng prompt caching at ng paggamit ng mas maliit na model para sa mga routine step sa kalkulasyong ito, higit pa kaysa sa anumang maliit na pagbabago sa prompt.

Kasama rin dito ang prompt injection. Kung nagbabasa ang iyong agent ng web page, issue tracker, o inbox, ang sumulat ng tekstong iyon ay nagbibigay rin ng instructions sa iyong agent. Karaniwang web search ang unang tool na nagbubukas ng ganitong access, at ipinapakita sa pagkonekta ng agent sa sarili mong SearXNG instance ang wiring at ang injection surface na nalilikha nito. Hindi mas mahusay na system prompt ang depensa. Ang mahalaga ay ang boundary, dahil hindi mahihikayat ang isang agent na mag-delete ng repository kung wala itong kakayahang mag-delete nito.

Anong roadmap ang dapat mong sundan?

Pumili ng isang curriculum at tapusin ito sa halip na tikman ang anim. Ang repository ng Microsoft na ai-agents-for-beginners ang pinakakumpletong libreng resource. Isa itong eighteen-lesson course na nakalampas na sa 70,000 stars noong July 2026, at malinaw itong tumutugma sa mga stage sa itaas. Kapaki-pakinabang ang mga roundup ng trending agent repository para makita kung ano ang available, pero hindi gaanong kapaki-pakinabang bilang syllabus. Ang listahang inayos ayon sa stars ay nakaayos ayon sa popularity, hindi ayon sa tamang pagkakasunod-sunod ng pagtuturo.

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

Gaano ito katagal?

Para sa taong marunong nang mag-program, isang gabi ang karaniwang kailangan para sa stages 1 at 2. Isang weekend naman ang stage 3, at karamihan ng oras ay napupunta sa pag-aaral ng mga tool description, hindi ng protocol. Ilang linggo ng aktuwal na paggamit ang kailangan para sa stages 4 at 5, dahil malalaman mo lang kung ano ang nakakalimutan ng agent mo kapag mino-monitor mo itong nakakalimot. Hindi talaga lubusang natatapos ang stage 6, dahil bawat bagong capability na ibinibigay mo ay muling nagbubukas dito.

Sa dalawang buwang tuloy-tuloy na paglalaan ng oras tuwing gabi, karamihan ng tao ay makakabuo ng agent na gumagana, may malinaw na limitasyon, at kapaki-pakinabang. Ang mga umaabot ng isang taon ay karaniwang patuloy na nagbabasa sa halip na bumuo.

FAQ

Kailangan ko bang alam 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 teorya ng machine learning kung magpapatuloy ka sa pag-fine-tune ng model. Ibang gawain ito na may ibang prerequisite.

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

Sumulat muna ng isang raw loop, saka gumamit ng framework. Pinapalitan ng framework ang 30 lines sa stage 2 ng isang configuration object. Maginhawa ito kapag alam mo na kung ano ang pinalitan nito, pero nakalilito bago iyon. Kapag hindi umaasal nang tama ang iyong agent, kailangan mong direktang unawain ang message list at ang mga resulta ng tool. Mas mahirap ito kung hindi mo pa nakikita ang mga iyon. Pagkatapos mong makabuo ng isang loop, makatitipid sa oras ang framework sa halip na itago ang mekanismo.

Magkano ang gagastusin para matuto 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. Ang panganib ay ang walang limitasyong loop na nagbi-bill 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 step. Kapag lokal mong pinatakbo ang model, mawawala ang token bill ngunit kakailanganin mo ng angkop na 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 may ilang step. 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 paragraph. Ang maling sagot ng agent ay isang masamang paragraph, kasama ang anumang ginawa nito dahil dito.