Paano Matutunan ang AI Agents Mula sa Simula

Ang landas sa anim na yugto

Upang 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 natitigil 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 ng tools. Iyan ang buong paksa. Ang lahat ng kasunod ay 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 mahalagang konsepto. Kung frameworks lamang ang kaya mong pangalanan, hindi mo pa ito natutuhan.

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

Ang talagang kailangan mo bago ang stage 1

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

• Marunong kang bumasa at sumulat ng Python o TypeScript sa antas ng isang script na may limampung linya.
• Komportable kang gumamit ng 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 model.

Iyon lang ang buong listahan. Hindi mo kailangan ng teorya sa machine learning, at hindi mo kailangang nakapag-train 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 skill na maaari mong matutuhan sa ibang pagkakataon mula sa pag-host ng Ollama sa isang VPS para mag-self-host ng LLM.

Madalas minamaliit ng mga tao ang bahagi tungkol sa shell. Nabibigo ang mga agent dahil sa permissions, paths, environment variables, at mga prosesong tahimik na namamatay. Kung napapapikit ka na sa terminal kapag nakakakita ng stack trace tungkol sa PATH o file mode, maglaan muna ng isang weekend sa Linux basics. Makakatipid ito ng isang buwan sa hinaharap.

Unang Yugto: ano ang agent, at 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 yunit ng gastos at ang yunit ng latency.

Pagkatapos, pag-aralan ang tool use, na siyang tanging tunay na bagong ideya sa buong larangan. Ilarawan 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 code mo ang function, ipinapadala ang output pabalik bilang message, at muling tinatanong ang model. Planner ang model na bumabasa ng text at nagsusulat ng text. Ang code sa panig mo ang may kakayahang magsagawa ng mga action. May pangalan ang code sa panig mo ng palitang iyon kapag nagsimula ka nang maghambing ng mga design: ito ang agent harness, ang loop, mga tool, at permissions na nakapalibot sa isang model na walang sariling mga ito.

Nagtatapos ang chatbot pagkatapos ng isang reply. Inuulit ng agent ang palitang iyon hanggang sa tumigil ang model sa paghingi ng mga tool. Ang pag-uulit na iyon ang buong pagkakaiba, at ito rin ang dahilan kung bakit magkakaiba ang failure modes. Isang beses nagbibigay ng maling sagot ang chatbot. Kumakilos ang agent batay sa maling sagot nang ilang beses bago ito mapansin.

Stage 2: Isulat mismo ang loop, isang beses

Huwag magsimula sa isang framework. Sumulat ng humigit-kumulang tatlumpung linya ng Python upang ikaw ang magtakda ng anyo ng code.

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 normal na pagtakbo, magpi-print ito ng isang talata na naglilista sa iyong mga filesystem at sa available nilang space, dahil humingi ang model ng 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 obserbahan kung paano nagbabago ang mga value.

Ngayon, sadyang sirain ito. Burahin ang linyang tool_use_id at basahin ang error, dahil nire-reject 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 kung dalawang beses tatakbo ang loop. Magtanong ng imposibleng sagutin at tingnan kung susuko ito o iikot nang walang katapusan.

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 i-rebuild, pero mali ito sa lahat ng iba pang environment. Tinutugunan ito ng Stage 6. Mas malawak na ipinapaliwanag ang mga konsepto sa ilalim ng loop sa paggawa 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 umaabot sa labas ng box: ticket system, database, at repository. Hindi scalable ang pagsusulat ng bespoke wrapper para sa bawat serbisyo at bawat agent.

Model Context Protocol (MCP) ang sagot na pinagtibay ng industriya. Naglalantad ang isang MCP server ng set ng mga tool sa karaniwang 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

Kailangan nito ng naka-install na Node, at ang directory argument lamang 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 magsulat. Tinalakay sa pagpapatakbo ng MCP servers sa isang VPS para sa AI coding agents kung paano ito patatakbuhin nang maayos, gamit ang service account at ipinaliliwanag na mga pagpipilian sa transport. Para sa ikalawang server na tumuturo sa aktuwal na data sa halip na scratch directory, ang self-hosting ng openGym, isang workout tracker ay may read-only server. Sa gayon, maaari kang magsanay sa pagtatanong tungkol sa sarili mong training history nang hindi binibigyan ang agent ng anumang maaari nitong masira.

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, nasisira ang context window. Ang tool na kayang mag-delete ng mga bagay ay kalaunan talagang magde-delete ng mga bagay.

Yugto 4: memory, na kadalasan ay mga file lamang

Karaniwang vector database ang unang ginagamit ng mga beginner dito. Huwag muna, kahit sa ngayon.

Walang memory ang agent sa pagitan ng mga call. Ipinapadala mong muli ang buong conversation sa bawat pagkakataon. Kaya mas mataas ang gastos sa bawat turn ng mahabang session kaysa sa maikling session. Dalawa ang problemang hinahati ng memory. Ang una ay kung ano ang kasya sa context window sa kasalukuyan. Pinamamahalaan mo ito sa pamamagitan ng pagbuod, pag-alis ng lumang tool output, at pag-cache ng stable prefix ng prompt para maliit na bahagi lamang ng presyo ang babayaran 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 dito ang format. Sabihin dito na basahin ang file bago magsimula at i-update ito kapag may natutuhan ito. Makukuha mo ang malaking bahagi ng pakinabang, at maaari mong buksan ang file para makita kung ano ang paniniwala ng 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 gumana ito kahit hindi mo ito mino-monitor.

Apat na tanong ang nagtatakda kung ligtas iwanang tumakbo nang walang nagbabantay ang isang agent. Ano ang nagti-trigger dito para hindi ito tumakbo nang walang gawain. Sa anong hangganan ito gumagana para manatiling maliit ang epekto ng isang pagkakamali. Paano bine-verify ang resulta, dahil palaging pumapasa ang agent na siya rin ang nagche-check ng sarili nitong output. Anong budget ang pipigil dito, batay man sa tokens o sa wall clock time. Ang sinadyang 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 mula 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 kung paano pinapataas ng unbounded loop ang token bill mo. Gawin ito nang isang beses gamit ang maliit na budget para hindi mo ito magawa nang hindi sinasadya 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 binubuong gumaganang sistema.

Patakbuhin ang agent bilang sarili nitong unprivileged user. Huwag itong patakbuhin bilang root o bilang sarili mong account. Sa ganitong paraan, directory lamang ang maaaring maapektuhan sa halip na buong machine. Ilayo ang credentials sa abot ng model, dahil anumang nasa context window ay maaaring maibalik nito sa pamamagitan ng tool call. Ang solusyon ay mga short-lived token na may limitadong saklaw, na ginagamit sa likod ng helper gaya ng inilalarawan sa pag-iwas na mailantad ang secrets sa iyong AI agents. Magtakda ng hard ceiling sa gastos. Sinisingil ang bawat iteration ng unattended loop kahit walang nagbabantay. Inilalarawan sa pagkontrol sa gastos ng AI agent sa isang always-on VPS ang mga cap at batching na nagpapanatiling kontrolado nito.

Kung tumatakbo ang iyong agent sa loob ng harness sa halip na sa script na ikaw mismo ang sumulat, configuration sa halip na code ang ilan sa mga ito. Sinasaklaw ng mga DeepSeek Harness plugin na sulit i-install ang marami sa parehong pangangailangan, kabilang ang budget caps, mga panuntunan sa tool permission, at injection scanning.

Mahalagang magkaroon ng 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 makapagpadala ang isang chatty agent ng ilang daang libong token sa iisang task habang patuloy na lumalaki ang 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.

Kasama rin dito ang prompt injection. Kung nagbabasa ang iyong agent ng web page, issue tracker, o inbox, ang sumulat ng text na iyon ay gumagawa rin ng mga instruction para sa iyong agent. Karaniwang web search ang unang tool na nagbubukas ng daang ito. Ipinapakita ng 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. Kung hindi kayang mag-delete ng repository ng agent, hindi ito makukumbinsing mag-delete nito.

Anong roadmap ang dapat mong sundan?

Pumili ng isang curriculum at tapusin ito sa halip na sumubok ng anim. Ang repository ng Microsoft na ai-agents-for-beginners ang pinakakumpletong libreng resource. Isa itong kursong may labingwalong lesson at umabot na sa 70,000 stars noong July 2026. Malinaw itong tumutugma sa mga stage sa itaas. Kapaki-pakinabang ang mga roundup ng trending agent repository para makita kung ano ang available, pero mas kaunti ang pakinabang ng mga ito bilang syllabus. Ang listahang inayos ayon sa stars ay nakaayos batay sa popularity, hindi sa pagkakasunod-sunod ng pagtuturo.

Kapag gusto mo ng totoong project na mapag-eensayuhan, coding agent ang pinakamagandang unang target. Agad ang feedback, malinaw ang mga tool, at madaling i-undo ang mga pagkakamali. Ipinapakita ng Pagpapatakbo ng coding AI agent sa VPS ang buong proseso mula simula hanggang dulo. Kung mas gusto mong pag-aralan ang mga gumaganang system kaysa bumuo mula sa zero, ipinapakita ng paghahambing sa 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, matatapos ang stages 1 at 2 sa loob ng isang gabi. Weekend ang kailangan para sa stage 3, at karamihan ng oras ay mapupunta sa mga paglalarawan ng tool, hindi sa protocol. Ilang linggo ng aktuwal na paggamit ang kailangan para sa stages 4 at 5, dahil malalaman mo lang kung ano ang nakakalimutan ng iyong agent sa pamamagitan ng pagmamasid dito habang nakakalimot. Hindi talaga ganap na 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 ay makakabuo ng gumagana, may malinaw na limitasyon, at kapaki-pakinabang na agent. Karaniwang umaabot ng isang taon ang mga taong 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 pag-uugnay ng mga tool request nito sa mga aktuwal na function. Karaniwang application programming lamang ito. Hindi mo kailangang humawak ng training, gradients, o datasets. Ang mga kasanayang tumutukoy kung gagana ang iyong agent ay kinabibilangan ng 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 ito at iba rin ang mga kinakailangan dito.

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 linya sa stage 2 ng isang configuration object. Maginhawa ito kapag alam mo na kung ano ang pinalitan nito, ngunit 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 makagawa ng isang loop, makatitipid sa oras ang framework 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 lilimitahan mo ang gastos. 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 pa lamang. Maglagay ng iteration cap sa bawat loop na isinusulat mo. Gumamit ng mas murang model para sa mga karaniwang step. Tinatanggal ng pagpapatakbo ng model nang lokal ang token bill, ngunit kapalit nito ang hardware requirement.

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. Dahil sa pag-uulit na ito, natatapos ng agent ang isang task na may ilang step. Ito rin ang dahilan kung bakit nangangailangan ang mga agent ng mga hangganang hindi kailangan ng mga chatbot. Ang maling sagot ng chatbot ay isang maling paragraph. Ang maling sagot ng agent ay isang maling paragraph, kasama ang anumang ginawa nito kaugnay nito.