AI Agent Nedir: Beş Klasik Tür, İki Rakip Tanım

Alandaki en eski örnek, A ve B diye iki kareden oluşan, her karenin temiz ya da kirli olabildiği bir dünyadaki elektrikli süpürgedir.¹ Her ders kitabında yaşamaya devam eder, çünkü bir agent’ın haklı ya da haksız olabildiği en küçük dünyadır.

Percept bir çifttir — neredeyim ve burası kirli mi — actions ise SUCK, LEFT ve RIGHT. Programın tamamı tek satırdır.

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";   

Bunu iki kareli dünyanın her başlangıç konfigürasyonuna karşı çalıştır:

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

Bu bir basit refleks agenttır: yalnızca mevcut percept’e göre hareket eder, öncesine dair hiçbir hafızası yoktur. Oyuncak bir kategori değil — termostat da böyledir, konuşma eklenmemiş tek bir dil modeli çağrısı da.

Şimdi onu gerçekliğin yaptığı şekilde boz. Gerçek bir süpürge robotunun halının altında A etiketi olan bir karesi değil, kir sensörü ve tamponu vardır. Konumu percept’ten çıkar ve başka hiçbir şeyi değiştirme:

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

Aynı program, iki kare. Bir başlangıç durumunda üç adımda bitirir; diğerinde sağdaki duvara beş yüz kez sürer ve pil bitene kadar sürmeye devam ederdi. İki durum arasındaki farkı algılayamaz, bu yüzden onlarda farklı davranamaz. Russell ve Norvig genel sonucu tek satırda söyler: kısmen gözlemlenebilir ortamlarda basit refleks agent’lar için sonsuz döngüler çoğu zaman kaçınılmazdır.¹

Daha zekice bir şeye uzanmadan önce ölçmeye değer, bir satıra mal olan ve hafıza gerektirmeyen bir çözüm var.

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

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

Baştan sona tek seed’li üreteçle, üç boyutta tamamen kirli bir koridorun iki bin çalıştırması:

Rastgeleleştirme döngüyü tamamen ortadan kaldırır. Ama maliyeti de vardır: ne yaptığını biliyorsan sekiz oda on beş hamle ister; bu agent ortalama 68,7 yapar ve bir kez 306 sürmüştür. Bütün bölümün minyatürü budur. Eklediğimiz her yetenek, önceki agent’ın başa çıkamadığı bir durumda doğruluk satın alır ve bunun bedelini önce adını koyman gereken bir para birimiyle tahsil eder.

Bir agent, ortamını sensörler aracılığıyla algılar ve actuators aracılığıyla hareket eder. Agent programı, percept’lerden actions’a giden fonksiyondur — yukarıdaki her listeleme bir tanesidir. Percept sequence, şimdiye kadar algılanan her şeydir; basit refleks agent bunun son öğesi dışındaki her şeyi yok sayar.

Rasyonellik, çoğu makalenin yanlış kullandığı kelimedir; onu doğru kullanmak bu bölümün geri kalanını kullanılabilir kılar. Bir agent kendi başına rasyonel ya da irrasyonel değildir. Russell ve Norvig rasyonel agent’ı, her olası percept sequence için, o sequence’ın kanıtları ve sahip olduğu yerleşik bilgi verildiğinde, performans ölçütünü maksimize etmesi beklenen action’ı seçen agent olarak tanımlar.¹ Performans ölçütü agent’ın içinde değildir: tasarımcıya aittir ve rasyonellik yalnızca ona göre tanımlanır.

Spesifikasyon geleneksel olarak dört şeyle, PEAS olarak yazılır: performans ölçütü, ortam, actuators, sensörler.

Hangi satırın aykırı olduğuna dikkat et. 2026’da agent inşa eden neredeyse her ekip E, A ve S’yi yazar — araç şemaları, integrations, mesaj formatı — çünkü kod onlarsız çalışmaz. Neredeyse kimse P’yi yazmaz. O olmadan “agent’ımız iyi gidiyor” kimsenin kontrol edebileceği bir anlama sahip değildir ve “rasyonel” sisteme hiç uygulanamaz, yalnızca bir demoya uygulanabilir. Bölüm 29, P’yi bir sayıya dönüştürmekle ilgilidir; var olma sebebi budur.

    ┌───────────────────────── 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

Görev ortamları ayrıca yedi eksen boyunca sınıflandırılır; bunların beşi buradaki zorluğun çoğunu belirler: tamamen ya da kısmen gözlemlenebilir, deterministic ya da değil, episodic ya da sequential, static ya da dynamic, known ya da unknown.¹ Gerçek bir ağ üzerinden gerçek araçlarla konuşan bir agent, bu beşinin de zor köşesindedir — temperature sıfırda bile non-deterministic (Bölüm 17) ve hafife alınanı, unknown, çünkü kendi araçlarının dünyaya ne yaptığının güvenilir bir modeline sahip değilsin. Bölüm 23’ün döngüsünün planlamadan çok error handling’e ihtiyaç duymasının sebebi budur.

Gerçek zeminler tek boyutlu değildir; bu yüzden dünyayı bir plana yükselt. Diyezler duvar, yıldızlar kir; robot orta odadan başlıyor:

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

Bariz yükseltme hafızadır. Agent bir harita tutar: üzerinde durduğu her kare ve tamponun tetiklendiği her kare. Kuralı, ziyaret etmediği bitişik bir kareye yürümektir — sağ, sonra aşağı, sonra sol, sonra yukarı — ve etrafındaki her şey bilindiğinde geri çekilmektir. Bu bir model tabanlı refleks agenttır: percept geçmişinden internal state korur, böylece şu anda göremediği şeye göre hareket edebilir.

Gerçek bir iyileştirmedir ve yine de yetmez:

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

Beş bin hamle, zeminin yarısı hiç görülmedi. Harita doğru ve kurallar doğru. Agent’ın yapamadığı şey, haritayı bir yere gitmek için kullanmaktır: kuralları yalnızca “dört komşumdan hangisine adım atmalıyım” sorusunu yanıtlar; bu yüzden yanındaki ziyaret edilmemiş kareler bittiğinde sekiz hamle uzakta ziyaret edilmemiş bir kare var ve onun üzerinde durmak istiyorum düşüncesini ifade etmenin yolu yoktur. Nerede olduğunu bilir. Nerede olmak istediğini bilmez.

Bir hedef tabanlı agent, dünya modelinin üstünde ortaya çıkarmak istediği durumun bir tanımını tutar ve orada biten bir tane bulana kadar action sequence’leri üzerinde arama yaparak actions seçer. Hedefler, action seçimini bir lookup’tan aramaya dönüştürür.

Hedef “kirli kare kalmasın”dır. Arama, en yakın kirli kareye breadth-first yürüyüştür ve döndürdüğü yol plandır.

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

Yirmi yedi hamle, zemin temiz. Ama pil sütununa ve planın son ayağına bak. Sütun 0 halılı: halılı bir kareyi geçmek altı birim pile mal olur, karo bir kare bir birime. Agent eve sütun 0’dan çıktı, çünkü bu sekiz yerine dört hamleydi; bu dört halılı hamle 24’e mal oldu, oysa sekiz hamlelik dolambaç 13’e mal olacaktı.

Başka türlü davranamaz. Bir hedef binary bir testtir: zemin temizdir ya da değildir. Temiz zeminle biten her plan onu eşit derecede sağlar; bu yüzden birkaç plan başarılı olduğunda agent’ın aralarında seçim yapacak hiçbir şeyi yoktur. Bir başarıyı diğerine tercih etmek, sonuçlar üzerinde bir sayı gerektirir ve bu sayı bir utility functiondır. Onu maksimize eden agent, utility tabanlı agenttır.

Koddaki değişiklik aramanın içindeki tek bir terimdir. Breadth-first search hamleleri sayar; onun yerine maliyeti saymasını sağla, Dijkstra algoritmasına ve farklı bir agent’a sahip olursun:

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

Dört ekstra hamle, on bir daha az pil birimi: yüzde yirmi bir daha ucuz. Aynı hedef, aynı harita, bir terim dışında aynı kod. İki agent yalnızca neyde iyi olmaya çalıştıkları bakımından ayrılır ve eve farklı rotalardan gider.

Bu aynı zamanda agent’ın üretemeyeceği bir şeye ihtiyaç duyduğu ilk noktadır. Birinin bir pil biriminin bir hamleye göre ne kadar değerli olduğuna karar vermesi gerekir. Utility, performans ölçütünün agent’ın hesaplama yapabileceği bir biçimde yazılmış halidir ve onu yazmak tasarımcının işidir. İnsanlar bir agent’ın “yanlış şeyi optimize ettiğini” söylediğinde neredeyse hiçbir zaman bir bug’dan söz etmezler. Bu satırın dikkatsiz yazıldığını kastederler.

Şimdi kir geri gelsin. Dört oda dört farklı hızda yeniden kirlenir ve agent’a bunlar asla söylenmez. Tick başına bir odayı ziyaret eder ve yalnızca o odayı görür. Performans ölçütü, 4.000 tick boyunca kirli geçirilen oda-tick’lerdir — daha düşük daha iyidir.

Bir öğrenen agent, ders kitabındaki ayrıştırmada, yukarıdakilerin herhangi birine eklenen üç parçadır: agent’ı değiştiren bir learning element, agent’ın sabit bir performans standardına göre nasıl gittiğini söyleyen bir critic ve öğretecekleri şeyler açısından denemeye değer actions öneren bir problem generator.¹ Aynı ortamda üç policy. İlki öğrenmez; ikincisi ve üçüncüsü aynı şeyi öğrenir ve onu farklı kullanır.

Gizli hızlar mutfak için 0,35, hol için 0,05, çalışma odası için 0,02 ve tavan arası için 0,01’di — ve learner A bunları buldu. Mutfağı evin en kirli odası olarak doğru tanımladı, sonra simülasyonun geri kalanında her tick mutfağa gitti; diğer üçü sonsuza kadar kirli kaldı. Hiç öğrenmemekten beş kat daha kötü ve bozuk değil.

Ders, utility bölümünün dersi. Learner A “ziyaret etmek üzere olduğum odanın kirli olma olasılığını” maksimize etti. Performans ölçütü “kirli geçirilen oda-tick’ler”di. Farklı sayılar; critic’in puanladığı ikinciydi ve kimse agent’a söylemedi. Learner B aynı öğrenilmiş oranı son ziyaretten beri geçen süreyle çarpar — herhangi bir kir bulma ihtimalinden ziyade bulmayı beklediği kir — ve başladığı devriyeyi yener.

Sonucu tek bir implementation detayı belirledi. Learner B’nin ilk sürümünde, üç ziyarette hiç kir çıkmayan bir odanın oranı tam olarak sıfır oluyordu — sıfır çarpı herhangi bir şey sıfırdır, bu yüzden o oda bir daha hiç ziyaret edilmiyor ve tahmin asla düzeltilemiyordu. Kesri smoothing etmek, başarılar artı bir bölü denemeler artı iki, 11.895’i 1.576’ya dönüştürdü. “Henüz gözlemlenmedi” ile “ölçüldü ve sıfır çıktı” farklı iddialardır; bunları aynı alanda saklayan bir sistem geri alamayacağı kararlar verir.

  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

Beşinin her biri bugün production’da başka bir adla var.

İki satır, maliyeti olan bir biçimde analojiden daha yakındır.

Chat, modeli internal olmayan model tabanlı refleks agent’tır. Ders kitabında state agent programının içindeki bir değişkendir. Chat’te transcript’tir: senin tarafında yaşar, her çağrıda bütünüyle yeniden gönderilir ve modelin içinde her seferinde sıfırdan yeniden kurulur. Bu, Bölüm 16’nın quadratic faturasıdır ve ders kitabının “state” etiketli bir kutu olarak çizdiği nesnenin aynısıdır. İşte fark; öncesindeki iki mesaj varken ve yokken tek bir follow-up sorusunda ölçüldü:

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."

Aynı model, aynı üç kelimelik kullanıcı girdisi ve ikincisi duvara süren koridor robotu. O çalıştırmada araç yoktu, bu yüzden 15 uydurmadır — ama follow-up’ı anlamlı kılan şey state’tir. Onu her seferinde yeniden kurarsın ve iki turlu konuşmada bunun için 2,3× input token ödersin. Bölüm 16 bu çarpanın kırkıncı turda nereye ulaştığını ölçtü.

Reflexion, programını değil girdisini değiştiren öğrenen agent’tır. Ders kitabı ayrıştırmasında learning element performans elementini değiştirir. Reflexion ağırlıkları olduğu gibi bırakır ve sonraki denemenin okuyacağı episodic buffer’a yansıtıcı metin yazar.³ Learning element bir prompt, hafıza bir database satırı, performans elementi donmuş bir modeldir — ve diagram ders kitabındakiyle aynıdır, değişmez.

Ve eşlemenin dürüst sınırı burada. Beş tür agent programını sınıflandırır. 2026’da o program ortadan ikiye bölünmüştür: bir kısmı senin kodundur, bir kısmı eğitmediğin ağırlıkların içindedir. Bir model kendi başına bir araç çağırmaya karar verdiğinde, goal test senin programında mı yoksa modelde mi? Taksonominin cevabı yoktur, çünkü yazıldığı zaman onun olabileceği başka bir yer yoktu — ve bu soru, iki modern tanımın tam olarak ayrıldığı yerdir.

Tanımlar davranış üzerine argümanlardır ve önünde bir trace varken yargılamak çok daha kolaydır.

Aşağıdaki döngü konuşmayı modele gönderir; cevapta bir tool call varsa aracı yürütür, sonucu ekler ve tamamını tekrar gönderir. Bu makinede OpenAI biçimli bir endpoint arkasındaki yerel Qwen2.5-0.5B-Instruct’a karşı çalışır — Bölüm 14’teki seam; dolayısıyla döngü portun arkasında ne olduğunu ne bilir ne umursar.

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");                       
}

İki satır bütün fikri taşır ve ikisi de işaretlidir; geri kalanı bookkeeping. Üç davranışın tamamı tek çalıştırmada görünür. Kendi yapabileceği bir şey sorulduğunda model cevaplar. Yapamayacağı bir şey sorulduğunda çağırır:

=== 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

Ve durur — üçüncü davranış, gözden kaçırması en kolay olanı, çünkü hiçbir şey olmuyormuş gibi görünür. Döngü biter çünkü tur 2 tool call olmadan geri gelmiştir. Buna kimse karar vermedi; model prose üreterek karar verdi. Bu programın termination condition’ı bir yokluğun işaretidir.

İki çalıştırma daha yer ayırmaya değer. İki şehri karşılaştırması istendiğinde model tek turda iki tool call’ı da çıkarır, iki okumayı da geri alır ve karşılaştırmayı yanlış yapar:

  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."

Araçlar çalıştı. Paralel çağrı çalıştı. Döngü çalıştı. Cevap yanlış; iki doğru sayı da transcript’te duruyor. Bir modeli döngüye sarmak ona reasoning kazandırmaz; yanlış olan bir modele, yanlış olmasına göre hareket etme yeteneği verir — bu, şimdiden Bölüm 30 ve Bölüm 29’un yarısıdır.

Şimdi işaretli return satırını sil ve döngünün bunun yerine sınırına kadar çalışmasına izin ver. Aynı soru, aynı 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

Dört kat input token, dört kat wall clock ve agent’ın kendisine ne sorulduğunu unuttuğu, kullanıcıyı birinci turda cevapladıkları bir soru hakkında sorguladığı bir son. Doğru cevap tur 2’de ekrandaydı ve ondan sonraki her tur transcript’i daha da kötüleştirdi.

Yani agent bir döngü değildir. Döngü artı ondan çıkma kuralıdır ve bu döngünün tam olarak bir böyle kuralı vardır. Bölüm 23 beş tane bulur ve her biri eksik olduğunda neyin bozulduğunu gösterir.

Paraphrase etmek yerine ikisini de alıntılıyoruz, çünkü kafa karışıklığı paraphrase’lerde üretilir.

Birinci tanım sınırı akışı kimin kontrol ettiğine koyar. Anthropic’in Building effective agents yazısı belirsizliği adlandırır ve hükmünü verir:

“Anthropic’te tüm bu varyasyonları agentic systems olarak kategorize ediyoruz, ancak workflows ile agents arasında önemli bir mimari ayrım çiziyoruz: Workflows, LLM’lerin ve araçların önceden tanımlanmış kod yolları üzerinden orchestrate edildiği sistemlerdir. Agents ise LLM’lerin kendi süreçlerini ve tool usage’larını dinamik olarak yönlendirdiği, görevleri nasıl gerçekleştirecekleri üzerinde kontrolü koruduğu sistemlerdir.”⁴

Test, kaynak kodun hakkında bir sorudur: sonraki adımı kim seçti? Programındaki bir switch: workflow. Model: agent. Aynı belge agent’ların “genellikle bir döngü içinde environmental feedback’e göre araç kullanan LLM’lerden ibaret” olduğunu söyler — bu da tam olarak yukarıdaki listelemedir.

İkinci tanım sınırı kullanıcıdan bağımsızlığa koyar. OpenAI’ın A practical guide to building agents belgesi tanım sayfasını şöyle açar:

“Geleneksel yazılım kullanıcıların workflows’u sadeleştirmesini ve otomatikleştirmesini sağlarken, agents aynı workflows’u kullanıcılar adına yüksek derecede bağımsızlıkla gerçekleştirebilir. Agents, görevleri senin adına bağımsız olarak tamamlayan sistemlerdir.”⁵

Aynı sayfada, iki cümle sonra şunu hariç tutar:

“LLM’leri entegre eden ama workflow execution’ı kontrol etmek için kullanmayan uygulamalar — basit chatbots, single-turn LLM’ler veya sentiment classifiers gibi — agent değildir.”⁵

Bu alıntıları sırayla oku. Açılış cümleleri çizgiyi bağımsızlıkta çizer: bu şey benden bağımsız gidip işi bitiriyor mu? Dördüncüsü çizgiyi execution controlde çizer; bu da Anthropic’in çizgisinin aynısıdır. Farklı testler, aynı sayfa ve üzerinde anlaşamadıkları gerçek sistemler var.

Altta bir kelime çarpışması var ve gerçek toplantılarda tartışmalara yol açıyor. İlk belgede workflow bir mimaridir ve agent olmayan şeydir. İkincide workflow, “kullanıcının hedefini karşılamak için yürütülmesi gereken adımlar dizisi”dir — işin kendisi; her agent’ın bir tane vardır. “Workflow’u agent ile değiştirdik” ilk tanım altında tutarlıdır, ikinci tanım altında ise neredeyse anlamsızdır.

2026’da var olan üç sistem, iki tanıma göre.

Üçünden ikisi taraf değiştirir. Bu iki belgeden birinin başarısızlığı değildir. Bir sistemin ne yaptığı konusunda tamamen anlaşan iki kişinin, ona ne deneceği konusunda bir saat anlaşamadığı toplantı türüne dair bir uyarıdır.

Tanımlar çarpışır çünkü her biri iki bağımsız soruyu tek kelimeye sıkıştırır. Onları ayırınca anlaşmazlık bir tabloya dönüşür; bu da bir hükümden daha kullanışlıdır.

Her tanım farklı bir hücreye itiraz eder ve diğer ikisi hiç tartışmalı değildir. Bu yüzden etiketin önemli olduğu yerlerde — sözleşmede, risk review’da, postmortem’de — yazmaya değer iki cümle “agent mı” değil, sonraki adımı kim seçti ve kim izliyordu olmalıdır. İkisi de kod okunarak yanıtlanabilir, hiçbiri kimsenin tanımına ihtiyaç duymaz ve birlikte etiketin yerine geçtiği her sonucu taşırlar.

Bunların hiçbiri yeni değil. Wooldridge ve Jennings 1995’te “agent”ın rakip anlamlarını taradı;⁶ Franklin ve Graesser bu bölümün sorusunu 1996’da sordu, dolaşımdaki tanımları topladı ve anlaşamadıklarını buldu.⁷ 2023 tarihli bir survey hâlâ agent’ları ilk ilkelerden tanımlar — “ortamlarını algılayan, karar veren ve actions alan yapay varlıklar”⁸ — çünkü atıf yapılacak yerleşmiş bir şey yoktu; CoALA ise hiç sınır çizmeden parçaları tarif eder.⁹ Otuz yıllık anlaşmama tercihi, kelimenin birden fazla iş yaptığını söyler.

Şimdi felsefeden önce gelen sonuç: fatura.

Buradaki her ölçüm aynı biçime sahip. Tek çağrı 39 input token’a mal oldu; aynı soru tek araçla iki çağrı boyunca 420’ye mal oldu; stopping rule’u kaldırılmış döngü altı çağrı boyunca 1.688’e mal oldu. Büyüme lineer olmaktan kötüdür, çünkü tur n önceki her turu yanında taşır: altı turluk çalıştırmanın prompt sütunu 187, 238, 261, 302, 327, 373 okur. Bölüm 16 toplamın $\Theta(n^2)$ olduğunu türetti ve eğriyi gerçek bir konuşma üzerinde fit etti. Bir agent, insan hiç görmese de her görevi o konuşmaya dönüştürür.

Bu ölçülen token sayıları, Bölüm 16’nın 6 Eylül 2026’da okuduğu fiyatlarla — milyon input token başına $2,00 ve milyon output başına $12,00 — ticari bir endpoint’e gitseydi, dört çalıştırmanın fiyatı şöyle olurdu:

İkinci satırın birinciye oranı akılda tutulacak sayıdır. Modelin zaten bildiği bir soruya daha kötü cevap için maliyetin yedi buçuk katı. Hiçbir şey yanlış yapılandırılmamıştı: bir araç vardı, model de onu kullandı — ve Bölüm 18’in bulgusu, zarar veren şeyin kataloğun fiyatı olduğu, doğruluğu olmadığı, burada tek araçlık katalogla en ucuz demosunu buluyor.

Bu yüzden iki belgenin de faydalı yarısı bunu inşa etmemekle ilgili olan yarısıdır. Anthropic nettir: mümkün olan en basit çözümü bul ve karmaşıklığı yalnızca gerektiğinde ekle; bu “agentic systems hiç inşa etmemek” anlamına gelebilir, çünkü agentic systems “daha iyi görev performansı için latency ve maliyetten feragat eder” ve “birçok uygulama için retrieval ve in-context örneklerle tek LLM çağrılarını optimize etmek genellikle yeterlidir”.⁴ Agent lehine sunduğu durum dardır: adım sayısını öngöremediğin ve yolu hardcode edemediğin açık uçlu problemler, güvendiğin bir ortamda, “daha yüksek maliyetleri ve compounding errors potansiyelini” kabul ederek.⁴ OpenAI’ın ekranı bunun ayna görüntüsüdür — karmaşık judgement, sürdürülemez kural setleri, unstructured data — ve aynı şekilde biter: “aksi halde deterministic bir çözüm yeterli olabilir”.⁵

Yani bu bölümün taksonomisinde: sabit sayıda adımın sabit sırayla çalışması pipeline’dır ve ona agent demek onu hızlandırmaz. Adım sayısı yolda ne bulduğuna bağlıysa bir döngü istersin — ve bu esnekliği N çağrı, quadratic transcript ve bir kez yerine N kez yanlış olabilen bir sistemle satın alırsın.

Artık taksonomiye, iki modern tanıma, onları uyumlu kılan iki eksene ve cevaplayan, çağıran ve duran kısa bir döngüye sahipsin.

O döngünün bitmek için tek yolu var: modelin araç istemeyi bırakması. Bölüm 23 onu bilerek, yedi kez bozar ve her bozulma bir parça ekler. İmkânsız bir görev ve hiç bitmez — turn cap. Bir gecelik çalışma ve fatura gelir — dolar cinsinden budget. Başarısız olan bir araç — modelin üzerine hareket edebileceği bir error. Aynı çağrı iki kez — idempotency key. Dokunmaması gereken bir dosya — human approval. Yarı yolda restart — session persistence. Üç dakika sessiz kalan bir araç — progress ve cancellation. Ortaya bir harness çıkar; bu kursun geri kalanının üzerinde çalıştığı dosya.

Geriye, bu bölümün tartışmalı diyagonalinin aslında sorduğu soru kalır. Kendi sonraki adımına karar veren bir döngü, ne zaman duracağına da karar vermek zorundadır; karar veremediğinde ne olduğunu az önce gördük: altı tur, dört kat fatura ve zaten cevapladığı bir soru hakkında kullanıcıyı sorgulayan bir agent. Durmak tek condition değildir. Kaç tane vardır ve hangisi önce tetiklenir?

Lilian Weng’in LLM Powered Autonomous Agents (2023) yazısı, bir language agent’ı planning, memory ve tool use olarak ayrıştıran en iyi bilinen çalışmadır ve iki vendor belgesiyle birlikte doğru sonraki okumadır; üç component’i bu kursun sırasıyla Bölüm 23, 24 ve 18’idir.

Bu bölümdeki her sayı bu makinede üretildi ve hiçbir şey tahmin edilmedi. Koridor, floor plan, üzerinde yürüyen dört agent ve üç patrol policy yukarıdaki TypeScript’tir; Node 22’de çalıştırıldı. Randomized agent’ın değerleri her biri 2.000 seed’li çalıştırmanın ortalamalarıdır ve patrol değerleri 4.000 tick’lik tek seed’li çalıştırmalardır. Model trace’leri, CPU’da float32 ile greedy decoding kullanan Qwen2.5-0.5B-Instruct modelinden gelir; ağırlıkları yükleyen ve OpenAI chat-completions biçimini konuşan küçük bir yerel Python endpoint’i tarafından loopback üzerinden servis edildi — yine seam, tensor’lar Python tarafında ve döngü TypeScript tarafında — bu yüzden token sayıları o modelin tokenizer’ına, latencies ise o makineye aittir. Dışarıdan alınan tek değerler maliyet tablosundaki iki fiyattır; bunlar Bölüm 16’nın OpenAI fiyatlandırma sayfasından 6 Eylül 2026’da okuduğu oranlardır ve burada gözlemlenmiş bir fatura olarak değil, locally measured token counts’a uygulanmış bir illustration olarak kullanılmıştır.