Paano gumagana ang isang AI agent: ang loop, patakbuhin nang walang API key

Hihilingin mo sa isang coding agent na ayusin ang isang typo at panoorin ang log na dumudulas: magbasa ng file, maghanap, magbasa ng isa pang file, mag-edit, patakbuhin ang mga test. Isang maliit na kahilingan, isang dosenang tawag sa modelo. Saan sila nanggagaling?

Ang AI agent ay isang loop. Ipinapadala ng iyong programa ang usapan sa modelo; ang modelo ay sumasagot o humihingi ng tool ("basahin ang file na ito"); pinapatakbo ng iyong programa ang tool, idinadagdag ang resulta sa usapan at tinatawag muli ang modelo. Inuulit ito hanggang sumagot ang modelo sa plain text. Ang mga coding agent tulad ng Claude Code, Codex at agent mode ng Cursor ay binuo sa paligid ng parehong loop na ito, na may mas maraming tool at mas maingat. Sa ibaba, patakbuhin mo ang isang 40-linyang bersyon na walang key, pagkatapos itutok ito sa isang tunay na modelo.

Ang loop sa isang larawan#

Isipin mo ang isang manager na hindi makakahawak ng kahit ano. Ang manager ay nagsusulat lamang ng mga tala: "pakiabot ng todo.txt". Isang assistant (ang iyong programa) ang pumupunta sa shelf, kinukuha ang file at inilalagay sa desk. Binabasa ito ng manager at isinusulat ang susunod na tala, o ang huling sagot.

Iyon ang buong trick. Hindi kailanman binubuksan ng modelo ang isang file o nagpapatakbo ng command. Nagsusulat ito ng text na nagsasabi kung aling tool ang tatawagin at kung anong mga argumento. Ang iyong code ang gumagawa ng trabaho at nag-uulat pabalik. Kung nakita mo na ang function calling, ito ay parehong mekanismo, na inuulit hanggang matapos ang trabaho.

Kaya mo bang ilagay ang isang lap ng loop sa tamang pagkakasunod-sunod?

Patakbuhin ito nang walang key#

Sabihin nating ang gawain ay: "Ilan ang item sa todo.txt?". Ang tool ay isang function na read_file na tumitingin sa isang maliit na dictionary sa halip na sa disk. At sa halip na isang tunay na modelo, may isang naka-script na laging gumagawa ng parehong dalawang bagay: humingi ng file, pagkatapos sumagot. Sapat na iyon upang makita ang bawat gumagalaw na bahagi. I-save ito bilang agent_loop.py (Python 3.10+, standard library lamang):

import json, os, urllib.request

NOTES = {"todo.txt": "buy milk\ncall Anna\nsend invoice"}

def read_file(name):
    return NOTES.get(name, "no such file")

TOOLS = {"read_file": read_file}
TOOL_SPECS = [{"type": "function", "function": {
    "name": "read_file", "description": "Read a note by file name",
    "parameters": {"type": "object",
                   "properties": {"name": {"type": "string"}},
                   "required": ["name"]}}}]

def scripted_model(messages):
    if messages[-1]["role"] == "user":      # first lap: ask for the file
        return {"role": "assistant", "content": None, "tool_calls": [{
            "id": "call_1", "type": "function",
            "function": {"name": "read_file",
                         "arguments": "{\"name\": \"todo.txt\"}"}}]}
    return {"role": "assistant", "content": "The file has 3 items."}

def real_model(messages):
    body = {"model": os.environ["LLM_MODEL"], "messages": messages,
            "tools": TOOL_SPECS}
    req = urllib.request.Request(
        os.environ["LLM_BASE_URL"] + "/chat/completions",
        data=json.dumps(body).encode(),
        headers={"Content-Type": "application/json",
                 "User-Agent": "agent-loop-demo/1.0",
                 "Authorization": "Bearer " + os.environ["LLM_API_KEY"]})
    with urllib.request.urlopen(req) as resp:
        data = json.load(resp)
    u = data["usage"]
    print("  usage: in", u["prompt_tokens"], "out", u["completion_tokens"])
    return data["choices"][0]["message"]

def run(task, model, max_steps=8):
    messages = [{"role": "user", "content": task}]
    for step in range(1, max_steps + 1):
        reply = model(messages)
        messages.append(reply)              # keep the model's turn in history
        calls = reply.get("tool_calls")
        if not calls:
            print(f"step {step}: answer -> {reply['content']}")
            return
        for call in calls:
            name = call["function"]["name"]
            args = json.loads(call["function"]["arguments"])
            result = TOOLS[name](**args)    # YOUR code does the work
            print(f"step {step}: tool {name}({args}) -> {result!r}")
            messages.append({"role": "tool", "tool_call_id": call["id"],
                             "content": result})
    print("stopped: max_steps reached")

model = real_model if os.environ.get("LLM_API_KEY") else scripted_model
run("How many items are in todo.txt?", model)

Patakbuhin ang python agent_loop.py. Kung walang LLM_API_KEY sa iyong environment, makukuha mo ang naka-script na modelo, at ang screen ay magpapakita ng eksaktong dalawang lap:

Tingnan ang tatlong linya, dahil hawak nila ang buong ideya:

• Ang messages.append(reply) ay nagpapanatili ng sariling turn ng modelo. Laktawan ito, at ang susunod na tawag ay naglalaman ng resulta ng tool na sumasagot sa isang kahilingang hindi pa nakita ng API; tinatanggihan ito ng karamihan ng API ng 400.
• Ang arguments ay dumarating bilang isang JSON string, kaya dumadaan ito sa json.loads bago mo tawagin ang function.
• Ang max_steps ay ang emergency brake. Ang isang modelo ay maaaring patuloy na humingi ng mga tool magpakailanman, kaya bawat tunay na agent ay may limitasyong tulad nito.

Itutok ang parehong loop sa isang tunay na modelo#

Isang bagay lamang ang nagbabago: kung sino ang gumaganap bilang modelo. Binabasa ng script ang tatlong environment variable, at kung may key, ipinapadala nito ang parehong messages sa isang OpenAI-compatible endpoint. Ang address ng CheapTokens ay https://api.cheaptokens.dev/v1 (OpenAI Chat Completions at Anthropic Messages compatible), at ang model id ay dapat ang buong isa mula sa docs: deepseek-ai/DeepSeek-V4-Flash-0731.

python agent_loop.py

export LLM_BASE_URL=https://api.cheaptokens.dev/v1
export LLM_API_KEY=<your key>
export LLM_MODEL=deepseek-ai/DeepSeek-V4-Flash-0731
python agent_loop.py

export LLM_BASE_URL=https://api.cheaptokens.dev/v1
export LLM_API_KEY=<your key>
export LLM_MODEL=zai-org/GLM-5.3-Flash
python agent_loop.py

Ang dapat mong makita ay parehong hugis tulad ng dati: step 1: tool read_file(...), pagkatapos step 2: answer -> ..., na may usage: na linya sa ilalim ng bawat tawag sa modelo. Ang pananalita ng sagot ay mag-iiba mula sa naka-script, at ang isang madaldal na modelo ay maaaring tumagal ng dagdag na lap. Normal iyon: ang modelo ang nagpapasya, ang loop ay sumusunod lamang. Ilayo ang key sa script mismo; ang environment variable ang ligtas na lugar (narito ang paano ito iimbak).

Ang mga linyang usage: ang kapaki-pakinabang na bahagi. Idagdag ang mga numerong in ng mas mahabang pagtakbo at makikita mo kung saan napupunta ang pera.

Bakit mas mahal ang bawat lap kaysa sa nauna#

Walang natatandaan ang modelo sa pagitan ng mga tawag. Ipinapadala ng bawat lap ang buong listahan ng messages muli: ang gawain, bawat naunang tawag sa tool, bawat resulta ng tool. (Ang parehong tuntunin ang nagpapamahal sa mahabang chat; ipinapakita ito ng multi-turn chat sa isang simpleng usapan.)

Ang lap 1 ay nagpapadala ng isang mensahe. Kung magpapatuloy ang loop, ang lap 6 ay nagpapadala ng labing-isa.

Sabihin nating ang isang tunay na gawain ay tumatagal ng 10 lap. Nagsisimula ito sa mga 2,000 token (mga instruksyon, listahan ng tool, ang iyong kahilingan), ang bawat lap ay nagdadagdag ng mga 1,500 (isang resulta ng tool kasama ang tala ng modelo), at ang modelo ay nagsusulat ng mga 300 token bawat lap. Ang lap 1 ay nagpapadala ng 2,000, ang lap 2 ay nagpapadala ng 3,500, ang lap 10 ay nagpapadala ng 15,500. Ang kabuuan ng unang bahagi ay 10 × 2,000 = 20,000 token; ang paglaki ay nagdadagdag ng 1,500 × 45 = 67,500 (45 ay 0+1+…+9), kaya ang input sa buong gawain ay 20,000 + 67,500 = 87,500 token. Ang output ay 10 × 300 = 3,000 token.

Ang teksto ng gawain mismo ay ilang pangungusap lamang, ngunit ang input side ay 87,500 token. Sa $0.015 bawat 1M input token, ang buong gawain sa DeepSeek-V4-Flash ay nagkakahalaga ng $0.0016. Narito ang parehong load sa mga modelo, kasama ang OpenRouter bilang sanggunian. Sa kabuuan, kasama ang input at output, mas mura ang CheapTokens kaysa sa OpenRouter sa load na ito:

Nakakatulong din dito ang isang presyo sa anumang oras ng araw: ang isang agent na tumatakbo magdamag ay kapareho ng presyo ng isa sa tanghali, at makikita mo ang lahat ng presyo sa pricing page. Para sa isang araw ng ganitong mga gawain, ilipat ang mga slider:

Ang mga field ay bawat tawag sa modelo: ang 8,750 ay ang average na input ng isang lap mula sa halimbawa sa itaas (87,500 ÷ 10), at ang 200 tawag ay 20 gawain × 10 lap. Ito ang dahilan kung bakit ang mga bill ng agent ay tungkol sa history, hindi sa tanong. Ang 20-step na halimbawa ay mas malalim na tumatalakay sa parehong epekto.

Saan pupunta mula sa 40 linya#

Ang script sa itaas ay isang sketch para sa pag-aaral. Kung gusto mo ang mahabang bersyon, may isang open course sa GitHub, justxor/agent-harness-course (README sa Russian, sinuri noong 31 Oktubre 2026). Ito ay plain Python 3.10+ na walang dependencies, ang code ay MIT-licensed, ang text ay CC BY 4.0. Pagkatapos mag-clone, ang python examples/02_agent_loop.py ay nagpapatakbo ng loop offline gamit ang naka-script na modelo, at ang python -m unittest discover -s tests ay nagpapatakbo ng 19 na test nito nang walang network. Ang kurso ay nagpapatuloy sa context compaction, memory, subagents, human approval ng mga mapanganib na aksyon, at cost tracking. Para sa isang tunay na modelo, binabasa nito ang LLM_PROVIDER, LLM_MODEL, LLM_API_KEY at, para sa OpenAI-compatible endpoints, LLM_BASE_URL: kunin ang eksaktong LLM_PROVIDER na halaga mula sa README nito.

Kapag gumagana na ang loop, ang susunod na hakbang ay isang tunay na key at isang tunay na gawain: ang docs ay may unang kahilingan sa isang minuto, at ang DeepSeek-V4-Flash ay isang magandang modelo para patakbuhin ang loop.