Co je AI agent: pět klasických typů a dvě soupeřící definice

Nejstarší příklad v oboru je vysavač ve světě dvou polí, A a B, z nichž každé je buď čisté, nebo špinavé.¹ Přežívá v každé učebnici, protože je to nejmenší svět, v němž agent může mít pravdu nebo se mýlit.

Percept je dvojice — kde jsem a zda je tady špína — a akce jsou SUCK, LEFT a RIGHT. Celý program je jeden řádek.

type Percept = { dirty: boolean; where?: "A" | "B" };
type Action = "SUCK" | "LEFT" | "RIGHT";

const textbook = (p: Percept): Action =>
  p.dirty ? "SUCK" : p.where === "A" ? "RIGHT" : "LEFT";   

Spusťte ho proti každé počáteční konfiguraci dvoupolového světa:

A dirty, B dirty, start A    -> steps=3 clean=true
A clean, B dirty, start A    -> steps=2 clean=true
A dirty, B clean, start B    -> steps=2 clean=true

To je simple reflex agent: jedná pouze podle aktuálního perceptu, bez paměti čehokoli před ním. Není to jen hračka — termostat je takový a stejně tak jedno volání jazykového modelu bez připojené konverzace.

Teď ho rozbijte tak, jak to dělá realita. Skutečný robotický vysavač má senzor špíny a nárazník, ne pod kobercem pole označené A. Vyjměte z perceptu polohu a nic jiného neměňte:

const dirtOnly = (p: Percept): Action => (p.dirty ? "SUCK" : "RIGHT");

A dirty, B dirty, start A    -> steps=3   clean=true   still dirty=0
      t=0 at=A percept={dirty:true}  -> SUCK
      t=1 at=A percept={dirty:false} -> RIGHT
      t=2 at=B percept={dirty:true}  -> SUCK

A dirty, B clean, start B    -> steps=500 clean=false  still dirty=1
      t=0 at=B percept={dirty:false} -> RIGHT
      t=1 at=B percept={dirty:false} -> RIGHT
      t=2 at=B percept={dirty:false} -> RIGHT
      t=3 at=B percept={dirty:false} -> RIGHT

Stejný program, dvě pole. Z jednoho počátečního stavu skončí ve třech krocích; z jiného pětsetkrát narazí do pravé zdi a pokračoval by, dokud by neumřela baterie. Nedokáže vnímat rozdíl mezi oběma situacemi, takže v nich nedokáže jednat odlišně. Russell a Norvig vyjadřují obecný výsledek jedním řádkem: nekonečné smyčky jsou pro simple reflex agents v částečně pozorovatelných prostředích často nevyhnutelné.¹

Existuje oprava, která stojí jeden řádek a žádnou paměť; stojí za to ji změřit, než sáhneme po něčem chytřejším.

let seed = 12345;
const rnd = () => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff);

const coin = (p: Percept): Action => (p.dirty ? "SUCK" : rnd() < 0.5 ? "LEFT" : "RIGHT");  

Dva tisíce běhů úplně špinavé chodby ve třech velikostech, po celou dobu jeden seedovaný generátor:

Randomizace smyčku úplně odstraní. Také něco stojí: osm místností potřebuje patnáct pohybů, pokud víte, co děláte, a tento agent má průměr 68,7 a jednou potřeboval 306. To je celá kapitola v miniatuře. Každá schopnost, kterou přidáme, kupuje správnost v případě, který předchozí agent nezvládl, a účtuje si ji v měně, kterou musíte nejdřív pojmenovat.

Agent vnímá své prostředí pomocí senzorů a jedná pomocí aktuátorů. Program agenta je funkce z perceptů na akce — každý výpis výše je jednou takovou funkcí. Sekvence perceptů je všechno dosud vnímané a simple reflex agent ignoruje všechno kromě poslední položky.

Racionalita je slovo, které většina článků chápe špatně, a když ho pochopíte správně, zbytek této kapitoly začne být použitelný. Agent není sám o sobě racionální nebo iracionální. Russell a Norvig definují racionálního agenta jako takového, který pro každou možnou sekvenci perceptů vybere akci, u níž se očekává, že maximalizuje jeho měřítko výkonu, vzhledem k důkazům v této sekvenci a k jakýmkoli vestavěným znalostem, které má.¹ Měřítko výkonu není uvnitř agenta: patří designérovi a racionalita je definována jen relativně k němu.

Specifikace se tradičně zapisuje jako čtyři věci, PEAS: performance measure, environment, actuators, sensors.

Všimněte si, který řádek je jiný než ostatní. Téměř každý tým, který v roce 2026 staví agenty, si zapisuje E, A a S — schémata nástrojů, integrace, formát zpráv — protože bez nich kód nepoběží. Téměř nikdo si nezapisuje P. Bez něj „náš agent si vede dobře“ nemá význam, který by kdokoli mohl ověřit, a „racionální“ se na systém vůbec nedá použít, jen na demonstraci. Kapitola 29 je o tom, jak P proměnit v číslo, a právě proto existuje.

    ┌───────────────────────── the environment ─────────────────────────┐
    │                                                                   │
    │   ┌──────────────────────── the agent ─────────────────────┐      │
    │   │                                                        │      │
 ───┼──►│  sensors  ──►  the agent program  ──►  actuators  ─────┼──────┼──►
percept │                                                        │    action
    │   └────────────────────────────────────────────────────────┘      │
    └───────────────────────────────────────────────────────────────────┘
                                   ▲
              the performance measure lives out here, in the head of
              whoever built the thing, and the agent cannot change it

Úlohová prostředí se dále klasifikují podle sedmi os, z nichž pět zde určuje většinu obtížnosti: plně nebo částečně pozorovatelné, deterministické nebo ne, epizodické nebo sekvenční, statické nebo dynamické, známé nebo neznámé.¹ Agent, který mluví se skutečnými nástroji přes skutečnou síť, je v těžkém rohu všech pěti — nedeterministický i při temperature zero (kapitola 17) a, což se podceňuje, neznámý, protože nemáte spolehlivý model toho, co vaše vlastní nástroje dělají se světem. Proto smyčka z kapitoly 23 potřebuje víc ošetření chyb než plánování.

Skutečné podlahy nejsou jednorozměrné, takže povyšte svět na plán. Mřížky jsou zdi, hvězdičky špína a robot začíná v prostřední komoře:

        col  0 1 2 3 4 5 6
      row 0  * . . # . . *
      row 1  . # . # . # .
      row 2  . # . S . # .        S = the robot starts here
      row 3  . # . # . # .
      row 4  * . . # . . *

Zjevné vylepšení je paměť. Agent si udržuje mapu: každé pole, na kterém stál, a každé pole, kde se ozval nárazník. Jeho pravidlo je vejít do sousedního pole, které ještě nenavštívil — doprava, pak dolů, pak doleva, pak nahoru — a ustoupit, když je všechno kolem něj známé. To je model-based reflex agent: udržuje si vnitřní stav z historie perceptů, takže může jednat podle toho, co právě nevidí.

Je to skutečné zlepšení, a pořád to nestačí:

5,000 steps allowed -> steps=5,000  distinct squares visited=13/25  still dirty=2/4

Pět tisíc pohybů, polovina podlahy nikdy nespatřena. Mapa je správně a pravidla jsou správně. Co agent nedokáže, je použít mapu k tomu, aby se někam dostal: jeho pravidla vždy jen odpovídají na otázku „do kterého ze svých čtyř sousedů mám vstoupit“, takže jakmile mu vedle něj dojdou nenavštívená pole, nemá způsob, jak vyjádřit myšlenku osm kroků odsud je nenavštívené pole a já bych na něm chtěl stát. Ví, kde je. Neví, kde chce být.

Goal-based agent drží nad svým modelem světa popis situace, kterou chce vyvolat, a vybírá akce hledáním v jejich sekvencích, dokud nenajde takovou, která tam končí. Cíle mění výběr akce z lookupu na hledání.

Cíl je „nezůstalo žádné špinavé pole“. Hledání je breadth-first průchod k nejbližšímu špinavému poli a cesta, kterou vrátí, je plán.

goal-based (fewest moves)      -> moves=27  battery=52  still dirty=0
      from 2,3 -> 4,6 via 5 moves:  2,3 2,4 3,4 4,4 4,5 4,6
      from 4,6 -> 0,6 via 4 moves:  4,6 3,6 2,6 1,6 0,6
      from 0,6 -> 4,0 via 10 moves: 0,6 0,5 0,4 1,4 2,4 2,3 2,2 3,2 4,2 4,1 4,0
      from 4,0 -> 0,0 via 4 moves:  4,0 3,0 2,0 1,0 0,0

Dvacet sedm pohybů, podlaha čistá. Ale podívejte se na sloupec baterie a poslední úsek plánu. Sloupec 0 je pokrytý kobercem: přechod přes kobercové pole stojí šest jednotek baterie, přes dlaždici jednu. Agent šel domů sloupcem 0, protože to jsou čtyři pohyby místo osmi, a ty čtyři pohyby po koberci stály 24, zatímco osmikroková oklika by stála 13.

Nemůže udělat nic jiného. Cíl je binární test: podlaha je čistá, nebo není. Každý plán, který skončí čistou podlahou, ho splňuje stejně, takže když uspěje několik plánů, agent mezi nimi nemá podle čeho vybírat. Dát jednomu úspěchu přednost před jiným vyžaduje číslo nad výsledky, a toto číslo je utility function. Agent, který ji maximalizuje, je utility-based agent.

Změna v kódu je jeden člen uvnitř hledání. Breadth-first search počítá pohyby; nechte ho počítat cenu a máte Dijkstrův algoritmus a jiného agenta:

const nd = dist.get(k)! + (byCost ? cell.cost : 1);   // <- the entire difference

goal-based    (fewest moves)   -> moves=27  battery=52  still dirty=0
utility-based (cheapest route) -> moves=31  battery=41  still dirty=0
      from 4,0 -> 0,0 via 8 moves: 4,0 4,1 4,2 3,2 2,2 1,2 0,2 0,1 0,0

Čtyři pohyby navíc, o jedenáct jednotek baterie méně: o jednadvacet procent levněji. Stejný cíl, stejná mapa, stejný kód až na jeden člen. Dva agenti se liší jen v tom, v čem se snaží být dobří, a domů jdou jinou cestou.

Toto je také první místo, kde agent potřebuje něco, co nedokáže vyrobit. Někdo musí rozhodnout, kolik má jednotka baterie hodnotu vzhledem k pohybu. Utility je měřítko výkonu zapsané ve formě, s níž agent umí počítat, a napsat ho je práce designéra. Když lidé říkají, že agent „optimalizoval špatnou věc“, téměř nikdy tím nemyslí bug. Myslí tím, že tento řádek byl napsán nedbale.

Teď nechte špínu vracet. Čtyři místnosti se znovu špiní čtyřmi různými rychlostmi a agent se je nikdy nedozví. Navštíví jednu místnost za tick a vidí jen tu místnost. Měřítko výkonu jsou místnost-ticky strávené ve špinavém stavu za 4 000 ticků — méně je lépe.

Learning agent je v učebnicovém rozkladu kterýkoli z výše uvedených plus tři části: learning element, který agenta mění, critic, který mu říká, jak si agent vede proti pevnému výkonovému standardu, a problem generator, který navrhuje akce, které stojí za vyzkoušení kvůli tomu, co by ho naučily.¹ Tři politiky ve stejném prostředí. První se neučí; druhá a třetí se učí totéž a používají to odlišně.

Skryté míry byly 0,35 pro kuchyň, 0,05 pro chodbu, 0,02 pro pracovnu a 0,01 pro půdu — a learner A je našel. Správně určil kuchyň jako nejšpinavější místnost v domě, pak po zbytek simulace chodil každým tickem do kuchyně, zatímco ostatní tři zůstávaly špinavé navždy. Je pětkrát horší než neučit se vůbec, a není rozbitý.

Poučení je stejné jako v části o utility. Learner A maximalizoval „pravděpodobnost, že místnost, kterou se chystám navštívit, je špinavá“. Měřítko výkonu bylo „místnost-ticky strávené ve špinavém stavu“. Různá čísla; to druhé hodnotil critic a agentovi to nikdo neřekl. Learner B násobí stejnou naučenou míru dobou od poslední návštěvy — špínu, kterou očekává najít, nikoli šanci najít nějakou — a poráží obchůzku, z níž vyšel.

Výsledek rozhodl jeden implementační detail. V první verzi learner B měla místnost, kde se ve třech návštěvách neobjevila žádná špína, míru přesně nula — a nula krát cokoli je nula, takže už nikdy nebyla navštívena a odhad už nikdy nešel opravit. Vyhlazení zlomku, úspěchy plus jedna přes pokusy plus dvě, změnilo 11 895 na 1 576. „Zatím nepozorováno“ a „změřeno a vyšlo nula“ jsou různá tvrzení a systém, který je ukládá do stejného pole, dělá rozhodnutí, která neumí vrátit.

  1  simple reflex    percept ────────────────────────────────► rules ────► action
  2  model-based      percept ──► [state] ──────────────────► rules ────► action
  3  goal-based       percept ──► [state] ──► [goal] ──────► search ───► action
  4  utility-based    percept ──► [state] ──► [goal] ──► [U] ──► argmax ► action
  5  learning         all of the above, plus [critic] ──► changes the parts above

Každý z pěti je dnes v produkci pod jiným názvem.

Dva řádky jsou blíž než analogie, a to způsobem, který stojí peníze.

Chat je model-based reflex agent, jehož model není interní. V učebnici je stav proměnná uvnitř programu agenta. V chatu je to transcript: žije na vaší straně, při každém volání se znovu posílá celý a uvnitř modelu se pokaždé znovu skládá od nuly. To je kvadratický účet z kapitoly 16 a je to stejný objekt, který učebnice nakreslila jako krabici označenou „state“. Tady je rozdíl, změřený na jedné navazující otázce s dvěma předchozími zprávami a bez nich:

with the transcript      prompt=67  "The current temperature in Lisbon, Portugal is 15°C."
without the transcript   prompt=29  "Lisbon is the capital of Portugal, not a city in Portugal."

Stejný model, stejná tři slova uživatelského vstupu, a druhý je robot v chodbě narážející do zdi. V tom běhu nebyly žádné nástroje, takže 15 je vymyšlená — ale stav je to, co dává navazující otázce vůbec nějaký význam. Pokaždé ho znovu budujete a platíte za něj 2,3× input tokenů ve dvoutahové konverzaci. Kapitola 16 měřila, kam se tento násobitel dostane ve čtyřicátém tahu.

Reflexion je learning agent, který mění svůj input, ne svůj program. V učebnicovém rozkladu learning element upravuje performance element. Reflexion nechává váhy být a zapisuje reflexivní text do epizodického bufferu, který další pokus čte.³ Learning element je prompt, paměť je řádek v databázi, performance element je zamrzlý model — a diagram je učebnicový, beze změny.

A tady je poctivý limit mapování. Pět typů klasifikuje program agenta. V roce 2026 je tento program rozdělený uprostřed: část je váš kód, část je uvnitř vah, které jste netrénovali. Když se model sám rozhodne zavolat nástroj, je test cíle ve vašem programu, nebo v modelu? Taxonomie nemá odpověď, protože když vznikala, neměl kde jinde být — a přesně u této otázky se dvě moderní definice rozcházejí.

Definice jsou argumenty o chování a posuzují se mnohem snáz, když máte před sebou stopu.

Smyčka níže posílá konverzaci modelu; pokud odpověď obsahuje tool call, provede nástroj, připojí výsledek a pošle celé vlákno znovu. Běží proti lokálnímu Qwen2.5-0.5B-Instruct za endpointem ve tvaru OpenAI na tomto stroji — šev z kapitoly 14, takže smyčka ani neví, ani se nestará, co je za portem.

const BASE = process.env.LLM_BASE_URL ?? "http://127.0.0.1:8799/v1";

async function loop(question: string, maxTurns = 6) {
  const messages: Msg[] = [
    { role: "system", content: SYSTEM },
    { role: "user", content: question },
  ];

  for (let turn = 1; turn <= maxTurns; turn++) {
    const reply = await call(messages, TOOLS);
    const calls = reply.choices[0].message.tool_calls ?? [];
    messages.push(reply.choices[0].message);

    if (!calls.length) return messages;                      

    for (const c of calls) {
      const out = runTool(c.function.name, JSON.parse(c.function.arguments));
      messages.push({ role: "tool", name: c.function.name, content: out });
    }
  }
  throw new Error("turn cap reached");                       
}

Dva řádky nesou celou myšlenku a oba jsou označené; zbytek je účetnictví. V jednom běhu jsou vidět všechna tři chování. Když se zeptáte na něco, co zvládne sám, model odpoví. Když se zeptáte na něco, co neumí, zavolá:

=== a question the model cannot answer, one tool available
  turn 1  prompt= 187  out= 21  finish=tool_calls  CALL get_temperature({"city": "Oslo"})
          tool  get_temperature -> {"city":"Oslo","celsius":4}
  turn 2  prompt= 238  out= 12  finish=stop        TEXT "The current temperature in Oslo is 4
                                                        degrees Celsius."
  => model calls=2  prompt tokens=425  output=33  wall=6,257 ms
  => stopped by: the model produced text instead of a call

A zastaví se — třetí chování, které se nejsnáze přehlédne, protože vypadá jako nicnedění. Smyčka končí, protože tah 2 se vrátil bez tool call. Nikdo o tom nerozhodl; rozhodl model tím, že emitoval prózu. Ukončovací podmínkou tohoto programu je známka absence.

Dva další běhy stojí za místo. Když má porovnat dvě města, model vydá obě tool calls v jednom tahu, dostane zpět obě měření a porovnání udělá špatně:

  turn 1  prompt= 188  out= 43  finish=tool_calls  CALL get_temperature({"city": "Oslo"}),
                                                        get_temperature({"city": "Lisbon"})
          tool  get_temperature -> {"city":"Oslo","celsius":4}
          tool  get_temperature -> {"city":"Lisbon","celsius":19}
  turn 2  prompt= 284  out= 13  finish=stop        TEXT "Oslo is currently warmer than Lisbon
                                                        at 4°C."

Nástroje fungovaly. Paralelní volání fungovalo. Smyčka fungovala. Odpověď je nepravdivá, přestože obě správná čísla sedí v transcriptu. Obalit model smyčkou neznamená, že začne uvažovat; dáváte modelu, který se mýlí, schopnost jednat podle svého omylu — což je kapitola 30 předem a polovina kapitoly 29.

Teď smažte označené return a nechte smyčku běžet až po limit. Stejná otázka, stejný model:

  turn 1  prompt= 187  out= 21  CALL get_temperature({"city": "Oslo"})
  turn 2  prompt= 238  out= 12  TEXT "The current temperature in Oslo is 4 degrees Celsius."
  turn 3  prompt= 261  out= 30  TEXT "Could you please specify the exact location you're..."
  turn 4  prompt= 302  out= 14  TEXT "Sure! Could you tell me which city you're interested in?"
  turn 5  prompt= 327  out= 35  TEXT "I'm sorry, but I need more details to provide an..."
  turn 6  prompt= 373  out= 12  TEXT "Which city would you like to know the temperature for?"
  => model calls=6  prompt tokens=1,688  output=124  wall=25,261 ms  stopped by: turn cap

Čtyřikrát input tokeny, čtyřikrát wall clock a konec, ve kterém agent zapomněl, na co se ho ptali, a vyslýchá uživatele kvůli otázce, na kterou odpověděl v prvním tahu. Správná odpověď byla na obrazovce ve druhém tahu a každý další tah transcript zhoršil.

Agent tedy není smyčka. Je to smyčka plus pravidlo, jak ji opustit, a tato má přesně jedno takové pravidlo. Kapitola 23 jich najde pět a ukáže, co se rozbije, když každé z nich chybí.

Obě citované, ne parafrázované, protože zmatek se vyrábí v parafrázích.

První definice klade hranici podle toho, kdo řídí tok. Anthropic ve Building effective agents tuto nejednoznačnost pojmenovává a rozhoduje ji takto:

„V Anthropic kategorizujeme všechny tyto varianty jako agentic systems, ale kreslíme důležitý architektonický rozdíl mezi workflows a agents: Workflows jsou systémy, kde jsou LLMs a nástroje orchestrované předdefinovanými cestami v kódu. Agents jsou naproti tomu systémy, kde LLMs dynamicky řídí své vlastní procesy a používání nástrojů a udržují kontrolu nad tím, jak plní úlohy.“⁴

Test je otázka na váš zdrojový kód: kdo zvolil další krok? switch ve vašem programu: workflow. Model: agent. Stejný dokument říká, že agents „jsou typicky jen LLMs používající nástroje na základě zpětné vazby z prostředí ve smyčce“ — což je přesně výpis výše.

Druhá definice klade hranici podle nezávislosti na uživateli. OpenAI v A practical guide to building agents otevírá definiční stránku takto:

„Zatímco konvenční software umožňuje uživatelům zjednodušit a automatizovat workflows, agents dokážou stejné workflows vykonávat jménem uživatelů s vysokou mírou nezávislosti. Agents jsou systémy, které nezávisle plní úlohy vaším jménem.“⁵

O dvě věty později, na stejné stránce, vylučuje:

„Aplikace, které integrují LLMs, ale nepoužívají je k řízení provádění workflow — představte si jednoduché chatboty, single-turn LLMs nebo sentiment classifiers — nejsou agents.“⁵

Čtěte tyto citace v pořadí. Úvodní věty kreslí hranici podle nezávislosti: odejde tato věc a dokončí práci beze mě? Čtvrtá ji kreslí podle řízení provádění, což je přesně Anthropicova hranice. Různé testy, stejná stránka, a existují skutečné systémy, na nichž se neshodnou.

Pod tím je slovní kolize a způsobuje hádky ve skutečných schůzkách. V prvním dokumentu je workflow architektura a je to věc, která není agent. V druhém je workflow „sekvence kroků, které musí být provedeny, aby byl splněn cíl uživatele“ — samotná práce, kterou má každý agent jednu. „Nahradili jsme workflow agentem“ je pod první definicí koherentní a pod druhou téměř bezvýznamné.

Tři systémy, které v roce 2026 existují, pod oběma definicemi.

Dva ze tří mění strany. To není selhání ani jednoho dokumentu. Je to varování před typem schůzky, kde dva lidé, kteří se úplně shodnou na tom, co systém dělá, stráví hodinu nesouhlasem o tom, jak mu říkat.

Definice narážejí, protože každá stlačuje dvě nezávislé otázky do jednoho slova. Oddělte je a nesoulad se změní v tabulku, která je užitečnější než verdikt.

Každá definice zpochybňuje jinou buňku a o dalších dvou není sporu. Takže když na štítku záleží — ve smlouvě, při revizi rizik, v postmortemu — dvě věty, které stojí za napsání, nejsou „je to agent“, ale kdo vybral další krok a kdo se díval. Na obě lze odpovědět čtením kódu, žádná nepotřebuje ničí definici a dohromady nesou všechny důsledky, které měl štítek zastupovat.

Nic z toho není nové. Wooldridge a Jennings zmapovali soupeřící významy slova „agent“ už v roce 1995;⁶ Franklin a Graesser položili otázku této kapitoly v roce 1996, shromáždili tehdy obíhající definice a zjistili, že se neshodují.⁷ Průzkum z roku 2023 stále definuje agenty od prvních principů — „umělé entity, které vnímají své prostředí, dělají rozhodnutí a provádějí akce“⁸ — protože neexistovalo nic ustáleného, co by šlo citovat, a CoALA popisuje části, místo aby vůbec kreslila hranici.⁹ Třicet let odmítání shody říká, že toto slovo dělá víc než jednu práci.

Teď důsledek, který přichází před filozofií: účet.

Každé měření tady má stejný tvar. Jedno volání stálo 39 input tokenů; stejná otázka s jedním nástrojem stála 420 napříč dvěma voláními; smyčka s odstraněným zastavovacím pravidlem stála 1 688 napříč šesti. Růst je horší než lineární, protože tah n nese všechny předchozí tahy s sebou: sloupec prompt té šestitahové jízdy zní 187, 238, 261, 302, 327, 373. Kapitola 16 odvodila, že součet je $\Theta(n^2)$, a proložila křivku na skutečné konverzaci. Agent mění každou úlohu v takovou konverzaci, ať ji člověk kdy vidí, nebo ne.

Kdyby tyto naměřené počty tokenů šly na komerční endpoint za sazby, které kapitola 16 četla 6. září 2026 — $2.00 za milion input tokenů a $12.00 za milion output — čtyři běhy vyjdou takto:

Řádek dva proti řádku jedna je číslo, které si zapamatujte. Sedm a půl násobek ceny za horší odpověď na otázku, kterou model už znal. Nic nebylo špatně nakonfigurováno: existoval nástroj, takže ho model použil — a zjištění kapitoly 18, že bolí cena katalogu, ne jeho přesnost, má tady svou nejlevnější demonstraci s katalogem o jedné položce.

Proto je užitečná polovina obou dokumentů ta polovina o tom, že to nemáte stavět. Anthropic je přímočarý: najděte nejjednodušší možné řešení a přidávejte složitost jen tehdy, když je potřeba, což „může znamenat nestavět agentic systems vůbec“, protože agentic systems „mění latenci a cenu za lepší výkon úlohy“ a „pro mnoho aplikací obvykle stačí optimalizovat jednotlivá LLM volání pomocí retrieval a in-context examples“.⁴ Jeho případ pro agenta je úzký: otevřené problémy, u nichž neumíte předvídat počet kroků a neumíte hardcodovat cestu, v prostředí, kterému důvěřujete, s přijetím „vyšších nákladů a potenciálu kumulovaných chyb“.⁴ Filtr OpenAI je zrcadlový obraz — složitý úsudek, neudržovatelné sady pravidel, nestrukturovaná data — a končí stejně: „jinak může stačit deterministické řešení“.⁵

Takže v taxonomii této kapitoly: pevný počet kroků v pevném pořadí je pipeline a říkat jí agent ji nezrychlí. Pokud počet kroků závisí na tom, co cestou najdete, chcete smyčku — a tuto flexibilitu kupujete za N volání, kvadratický transcript a systém, který se může mýlit Nkrát místo jednou.

Teď máte taxonomii, obě moderní definice, dvě osy, které je dělají kompatibilními, a krátkou smyčku, která odpovídá, volá a zastavuje.

Tato smyčka má jeden způsob, jak skončit: model přestane žádat o nástroje. Kapitola 23 ji schválně rozbije sedmkrát a každá porucha přidá jeden díl. Nemožná úloha a nikdy neskončí — limit tahů. Noc běhu a přijde účet — rozpočet v dolarech. Nástroj selže — chyba, podle které může model jednat. Stejné volání dvakrát — idempotency key. Soubor, na který neměl sahat — human approval. Restart uprostřed — perzistence session. Nástroj, který tři minuty mlčí — progress a cancellation. Výsledkem je harness, soubor, na kterém běží zbytek tohoto kurzu.

Zbývá otázka, o kterou ve sporné diagonále této kapitoly skutečně šlo. Smyčka, která rozhoduje o svém vlastním dalším kroku, musí rozhodnout, kdy skončit, a právě jsme viděli, co se stane, když to neumí: šest tahů, čtyřikrát vyšší účet a agent vyslýchající uživatele kvůli otázce, na kterou už odpověděl. Zastavení není jedna podmínka. Kolik jich je a která se spustí první?

Lilian Weng a LLM Powered Autonomous Agents (2023) je nejznámější rozklad language agent na plánování, paměť a používání nástrojů a je správným dalším čtením vedle dvou vendor dokumentů; jeho tři komponenty jsou kapitoly 23, 24 a 18 tohoto kurzu v tomto pořadí.

Každé číslo v této kapitole vzniklo na tomto stroji a nic nebylo odhadnuto. Chodba, plán podlahy, čtyři agenti, kteří po ní chodí, a tři obchůzkové politiky jsou TypeScript výše, spuštěný na Node 22; čísla randomizovaného agenta jsou průměry přes 2 000 seedovaných běhů pro každý případ a čísla obchůzky jsou jednotlivé seedované běhy o 4 000 ticích. Stopy modelu pocházejí z Qwen2.5-0.5B-Instruct ve float32 na CPU s greedy decoding, servírovaného přes loopback malým lokálním Python endpointem, který načítá váhy a mluví tvarem OpenAI chat-completions — zase šev, s tensory na straně Pythonu a smyčkou na straně TypeScriptu — takže počty tokenů patří tokenizeru tohoto modelu a latence tomuto stroji. Jediné údaje převzaté odjinud jsou dvě ceny v cenové tabulce, což jsou sazby, které kapitola 16 četla z cenové stránky OpenAI 6. září 2026, zde aplikované na lokálně změřené počty tokenů jako ilustrace, ne jako pozorovaná faktura.