Multi-Agent Orchestration: Beş Kalıp ve Hangisi Ne Zaman Kazanır

Portekizli bir şirket, FT-2026-0918 numaralı fatura hakkında yazıyor. E-posta KDV’nin yanlış göründüğünü söylüyor ve faturayı ekliyor: net EUR 248.00, %21 KDV uygulanmış, EUR 52.08, toplam EUR 300.08.

Yanıtlamak için gereken bilgiler üç yerde duruyor ve bunlardan yalnızca biri e-postada:

Üçünü birleştirince fatura yanlış: reverse charge uygulanmalıydı, KDV sıfır olmalıydı, EUR 52.08 tutarında bir alacak dekontu borçlu. Yalnızca faturaya bakarsan aritmetik kusursuzdur — 248.00 artı 52.08, 300.08 eder — ve öyle söylersin.

E-posta “Portekizli bir şirketiz” diyor. Bu bir iddia, kayıt değil; hiçbir faturalama sistemi bir iddiaya dayanarak alacak dekontu düzenlemez. Tuzak hile değil: iş kararının kimsenin getirmeyi düşünmediği bir bilgiye ihtiyaç duyduğu sıradan business work şekli.

Yukarıdaki her şey, Bölüm 23’tekine benzer bir scripted provider’a karşı, tam olarak tek kuralla çalışır:

Bir cevap yalnızca prompt’unda bulunan bir bilgiyi kullanabilir.

“Model”, sahip olduğu her tool’u katalog sırasıyla bir kez ister, sonra görebildiği metne sabit bir kural uygular. Hiçbir şey arrangement’a özel script’lenmedi; bu yüzden açılış tablosundaki farklar model zekâsı iddiaları değil: ölçülmüş information routing. Gerçek bir model bunun üstüne kendi hatalarını ekler; bunları ortadan kaldırmaz.

Aşağıdaki beş ad Anthropic’in Building effective agents yazısından; bu kelime dağarcığının oturduğu yer orası.¹ Beş fikrin hiçbiri yeni değil; hangi evi neyi adlandırdı — ve hangi fikir daha eski — bunu bilmek değerin yarısı.

/* 1. Prompt chaining: a fixed pipeline. The control flow is yours. */
export async function chain(steps: Step[], first: string) {
  let carry = first, all = first;
  for (const s of steps) {
    const r = await step(s.role, s.system, s.accumulate ? all : carry);   
    carry = r.text;
    all = `${all}\n${r.text}`;
  }
  return carry;
}

/* 2. Routing: one cheap call picks the branch. The fallback is not a model. */
export async function route<T>(input: string, classify: Classifier,
                               routes: Record<string, Branch<T>>, fallback: Branch<T>) {
  let label: string | undefined;
  try { label = await classify(input); } catch { label = undefined; }
  return ((label && routes[label]) || fallback)(input);                    
}

/* 3. Parallelisation. The pattern IS this line. */
export const parallel = <T>(workers: Branch<T>[], input: string) =>
  Promise.all(workers.map((w) => w(input)));                              

/* 4. Orchestrator-workers: an agent behind a tool. Chapter 18's interface, unchanged. */
export function agentTool(o: WorkerSpec): Tool {
  return {
    name: o.name, description: o.description, readOnly: true,
    parameters: { type: "object", properties: { question: { type: "string" } } },
    async run(args: { question: string }) {
      const child = newRun(o.system, args.question);          // its own window
      await runTracked(child, o.tools, o.usage);              // its own limits
      const conclusion = child.output ?? "no result";
      if (!o.carryFindings) return conclusion;                             
      return `${conclusion}\nFINDINGS ${evidence(child)}`;                 
    },
  };
}

/* 5. Evaluator-optimiser: make, judge, remake. Rounds are calls. */
export async function refine(make: Make, judge: Judge, maxRounds: number) {
  let draft = "", feedback: string | undefined;
  for (let r = 1; r <= maxRounds; r++) {
    draft = (await make(feedback)).text;
    const j = await judge(draft);
    if (j.ok) return { draft, rounds: r };
    feedback = j.note;
  }
  return { draft, rounds: maxRounds };
}

Bütün araç seti bu: beş function, framework yok, parallel olanı ise tek satır — onu çizmek yerine yazmanın amacı da bu. Şimdi her birini sırayla, kökeni, fiyatı ve yanlış olduğu durumla birlikte ele alalım.

Prompt chaining, “bir görevi, her LLM call’unun bir öncekinin output’unu işlediği adımlar dizisine ayırır”.¹ Fikir dil modellerinden daha eski: bu bir pipeline’dır; pipeline’ın takası da veri gelmeden önce sabitlenmiş bir control flow karşılığında netliktir.

Görevimiz için dört adım: fatura alanlarını çıkar, aritmetiği kontrol et, ne borçlu olunduğuna karar ver, yanıtı yaz. Burada iki farklı şekilde başarısız oluyor; bu da tek başarısızlıktan daha çok şey öğretiyor.

--- relay: each step sees only the previous step's output
extract: FIELDS invoice_id=FT-2026-0918 net=248.00 vat_rate_applied=21 vat_amount=52.08 ...
check:   ARITHMETIC ok 248.00+52.08=300.08
decide:  VERDICT=unknown reason=no_invoice_in_context
draft:   "we are looking into invoice FT-2026-0918 and will come back to you."

--- accumulating: each step sees the email and everything produced so far
extract: FIELDS invoice_id=FT-2026-0918 net=248.00 vat_rate_applied=21 ...
check:   ARITHMETIC ok 248.00+52.08=300.08
decide:  VERDICT=invoice_correct reason=net_248.00_plus_21pct_vat_52.08_equals_300.08
draft:   "we have checked FT-2026-0918 and it is correct... Nothing is owed back."

Relay chain $0.001940 tuttu ve fatura alanlarını ikinci ile üçüncü adımlar arasında kaybetti; çünkü üçüncü adıma yalnızca aritmetik hakkında bir cümle verildi, başka hiçbir şey değil. Bir bekletme mesajı üretti: işe yaramaz ve görünür şekilde işe yaramaz.

Accumulating chain — açılış tablosundaki satır — $0.003780 tuttu; bu, aynı dört call için %95 daha fazla, çünkü artık her adım kendinden önceki her şeyi taşıyor. Tehlikeli output’u üretti. Akıcı, aritmetiğini kaynak gösteren, bahsettiği her sayıda doğru ve EUR 52.08 borçluyken müşteriye hiçbir şey borçlu olunmadığını söyleyen.

İkisi arasındaki fark tek bir ternary. Daha az taşıyan bir chain bariz eksik cevaplar üretir; her şeyi taşıyan bir chain ise kendinden emin biçimde yanlış cevaplar üretir — ve yalnızca ikinci tür gönderilir.

Gerçek başarısızlık ikisi de değil. Gerçek başarısızlık, pipeline’ın daha hiçbir şeyi okumadan bu görevin bir e-postanın içeriği üzerinde dört adımdan oluştuğuna karar vermesidir. Bu yapının hiçbir yerinde “kayıt ülkesi bu e-postada yok; git al” diyecek bir yer yok. Chaining, decomposition önceden bilindiğinde ve stabil olduğunda doğrudur. Burada bir tahmindi ve tahmin ship edildi.

Routing, “bir input’u sınıflandırır ve onu uzmanlaşmış bir followup task’a yönlendirir”.¹ Adı yeni; mekanizma dispatcher’dır ve bu kitaptaki neredeyse her şeyden eskidir. Yeni olan, classifier’ın bir model olabilmesidir — onu bir switch’in hiç yaşamadığı şekillerde başarısız yapan da budur.

const answer = await route(email,
  (q) => classifyWithSmallModel(q),          // cheap model, one call
  { billing: billingAgent, tax: taxAgent, dunning: dunningAgent },
  taxAgent,                                  // deterministic, chosen in advance
);

Son argüman hakkında iki şey. Bu error handling değildir; kalıbın kendisidir. Model tabanlı bir router’ın dispatcher’da olmayan bir failure mode’u vardır: var olmayan bir label döndürebilir, time out olabilir ya da — pahalı olan — yanlış olduğuna dair sinyal olmadan makul ama yanlış bir label döndürebilir. Üçü de bir yere düşmek zorunda ve o yer başka bir model call olamaz; çünkü zaten model call’ların başarısız olduğu branch’tesin.

İkinci şey, router’ın kendi prompt’unun ücretsiz olmadığıdır. Bir model seçmek için router’ın seçebileceği bir model kataloğuna ihtiyacı vardır ve içindeki her girdi, router’ın kullanıcının sorusunu okumadan önce ödediği input’tur. Bu kursun fiyatlandırmada kullandığı input rate ile yaklaşık 3.800 token’lık bir katalog, daha şimdiden açılış tablosundaki beş çağrılık agent run’ın tamamı kadar tutar. Pratikte routing çağrısı ucuz bir model üzerinde çalışır ve routing’in kendi masrafını çıkarmasının bütün nedeni de budur; ama bunu varsaymak yerine aritmetiği o yönde yapmaya değer. Routing, tam da yönlendirilen task routing kararının kendisinden daha ucuz olduğunda yanlıştır.

Anthropic bunu ikiye ayırır: sectioning — “bir görevi paralel çalışan bağımsız subtasks’a bölmek” — ve voting — “çeşitli outputs almak için aynı görevi birden çok kez çalıştırmak”.¹ Aynı diyagramı paylaşırlar ve bunun dışında neredeyse hiçbir şeyi paylaşmazlar.

Sectioning ucuz kazançtır ve patterns.ts satırıdır: üç uzman — billing, tax, policy — her biri kendi window’u ve tool’larıyla, aynı e-posta üzerinde, sonunda bir synthesis call. Aynı iş, iki farklı sırayla:

Token token aynı, 1,8 kat daha hızlı. Kalıbın kendi adını hak etmesinin nedeni bu: beşinin içinde hiçbir şeye maliyet eklemeden bir şeyi iyileştiren tek kalıp. Püf noktası, section’ların gerçekten bağımsız olması gerektiğidir — section B’ye section A’nın ürettiği bir bilgi ver ve Promise.all ikisini de henüz var olmayan bir state’e karşı çalıştırır. for loop bu bug’ı sakladı; tek satırlık olan ortaya çıkarıyor.

Voting, aynı resmi giyen başka bir canlıdır. Aynı soruyu k kez çalıştırıp çoğunluğu almak self-consistency’dir; Wang ve diğerleri tarafından Mart 2022’de bir decoding stratejisi olarak yayımlandı, kimse ona orchestration pattern demeden neredeyse üç yıl önce. Özeti mekanizma konusunda nettir — “yalnızca greedy olanı almak yerine önce çeşitli reasoning path’lerden oluşan bir küme sample eder, sonra sampled reasoning path’leri marginalize ederek en tutarlı yanıtı seçer” — ve kazanç konusunda da nettir: GSM8K’da +17,9 puan.²

Resmin sakladığı iki sonuç çıkar. Birincisi, voting Bölüm 17’nin sampling’ini gerektirir: temperature sıfırda tüm k samples aynı sample’dır ve çoğunluk, k kez parası ödenmiş tek bir cevaptır. İkincisi, yalnızca çoğunluğun anlamlı olduğu yerde çalışır — yukarıdaki fatura yanıtında sayılacak bir şey yoktur, çünkü beş draft beş farklı cümledir. Voting, kısa ve karşılaştırılabilir cevabı olan görevler içindir; Wang’ın benchmark’ları tam olarak budur, customer-facing bir agent’ın yaptığı neredeyse hiçbir şey değil.

Burada, cevapları yargılanmak yerine hesaplanan 20 üç adımlı word problem üzerinde, Bölüm 23’ün yerel modeli adım adım reasoning yaparken ölçüldü:

Beş kat call, beş kat token, tam beş kat fatura ve bir tane bile ek doğru cevap yok. Voting bir bahistir, iyileştirme değil; bu run bahsi kaybetti.

Bunu Wang’ın çürütmesi diye alıntılamadan önce iki not. Yirmi trial, %45 ile %60’ı ayırt edemez — interval iddianın genişliği kadar, bu da Bölüm 4’ün disiplininin kendi sonucuma uygulanmış hâli. Yayımlanmış kazançlar da orders of magnitude daha büyük modellerden geliyor; voting’in marginalize ettiği diverse reasoning path’ler orada gerçekten diverse. Aktarılan şey sayı değil: multiplier kesin ve önceden bilinirken kazancın böyle olmaması.

Orchestrator-workers workflow’da “merkezi bir LLM görevleri dinamik olarak parçalara ayırır, worker LLM’lere delegate eder ve sonuçlarını synthesize eder”; sectioning’den farkı da “subtasks’ın önceden tanımlı olmaması, orchestrator tarafından belirlenmesidir”.¹ Buradaki köken dil modellerinden gelmiyor: bu master-worker’dır; worker’ların bulguları bir controller’ın okuduğu shared space’e yazdığı sürüm de 1970’lerdeki speech understanding araştırmalarından blackboard architecture’dır. 2026’da yeni olan, controller’ın bir model olması ve bu yüzden decomposition’ın input başına kararlaştırılabilmesidir — esneklik ve maliyet, tek cümlede.

Tek agent’ın 5 call’una karşı 12 model call tuttu ve aynı karara vardı. Sonra yakından bakmaya değer bir şey yaptı:

orchestrator final: VERDICT=credit_note_due amount=52.08 source=worker_unverified
                  | PO_MISMATCH=yes source=worker_unverified
single agent:       VERDICT=credit_note_due amount=52.08 reason=reverse_charge_should_have_applied
                  | PO_MISMATCH=yes invoice_says=PO-4417 order_says=PO-4471

İkisi de doğru. Yalnızca biri nedenini biliyor. Tax worker kendi window’unda faturaya, siparişe ve vergi tablosuna sahipti, sonuca vardı ve ayrıca — kimse sormamışken — faturadaki purchase order numarasının sipariştekiyle eşleşmediğini fark etti. Sonra bir summary döndürdü. Orchestrator iki ifadeyi de tekrarlayabilir ve ikisini de kontrol edemez; çünkü evidence hiç görmediği bir window’da kaldı. Bölüm 24’ün kapanış sorusu böyle yanıtlanır: parent, child’ın yazmayı seçtiği her şeye bakabilir.

Düzeltme bir flag’dir ve bir fiyatı vardır:

Yüzde on iki daha fazla input tokens, %8,3 daha fazla para ve source=worker_unverified ifadesi cevaptan kaybolur. Her multi-agent system’daki takas budur ve neredeyse hiç açıkça söylenmez: child’ın temiz window’u değerlidir, parent’ın onu audit etme yeteneği para ödemeye değerdir ve ikisine de ücretsiz sahip olamazsın.

Peki orchestrator-workers ne zaman yanlıştır? Burada, bu görevde. Aynı dört tool’a sahip tek agent’ın da ulaştığı doğru cevabı, 1,66 kat maliyet ve 2,3 kat wall clock karşılığında satın aldı ve o cevabı savunmayı zorlaştırdı. Anthropic’in kendi rehberliği pattern’ler başlamadan önce bunu söyler: “mümkün olan en basit çözümü” bul ve “yalnızca gerektiğinde karmaşıklığı artır”, çünkü “agentic systems çoğu zaman daha iyi task performance için latency ve cost takas eder”.¹ Yukarıdaki tablolar o cümlenin altına sayılar konmuş hâlidir.

Bir call üretir, diğeri değerlendirir ve loop değerlendirme geçene kadar tekrarlar.¹ Yayımlanmış ataları Self-Refine — “generator, refiner, and feedback provider” olarak aynı model, yedi task üzerinde ortalama yaklaşık 20 puan absolute improvement raporlar³ — ve Reflexion’dır; critique’i attempts boyunca episodic buffer’da saklar ve baseline %80’e ulaşırken HumanEval’de %91 pass@1 raporlar.⁴

Cost model beşinin en basitidir: round başına iki call ve round count senin değildir. Tek call alan bir task üzerinde üç refinement round altı call demektir; bu yüzden pattern’in tabanı 6×, tavanı ise koyduğun cap neyse odur — bu da Bölüm 23’ün budget exit’ini düzenli değil zorunlu kılar.

Tavan daha inceliklidir ve ölçülebilir. Aynı 20 problemde yerel model 9’unu doğru yanıtladı. Sonra bu cevapların her biri gösterildi ve doğru olup olmadığı soruldu — cevabın kendisine ait olduğu söylenmeden; bu da flattery confound’u kaldırıp capability olanı bırakır:

Bu, section title’ın ima ettiğinden daha iyi bir yargıç ve iddia etmek yerine ölçmenin amacı da bunu söylemek: doğru olan hiçbir şeyi engellemedi ve 11 hatadan 8’ini yakaladı. Bir filter olarak call’larına değer.

Bir stopping rule olarak ise — evaluator-optimiser loop’un onu fiilen kullanma şekli budur — o üç approval bütün hikâyedir: loop’u elde yanlış cevapla bitirirler ve hiçbir extra round onlara ulaşamaz. Bir refinement loop, judge’ından daha doğru olamaz. Daha fazla round satın almak, judge’ın görebildiği hatalara tam fiyatla deneme satın almaktır; göremediklerine karşı ise hiçbir şey satın almaz.

Dolayısıyla kural: bir evaluator yalnızca generator’da olmayan bir şeye sahipse call’larını hak eder. Bir compiler, test suite, schema validator, farklı bir model, bir insan. Self-Refine’ın kendi sonuçları human preference ve task metrics’e göre ölçülür; asla modelin kendisi hakkındaki görüşüne göre değil. Evaluator’ının tek avantajı farklı bir prompt ise agreement için iki kat ödüyorsun. Bölüm 29, gerçek avantaja sahip sürümü kurar: cevapları önceden yazılmış bir golden set.

Yukarıdaki beşli senin code’un için şekillerdir. Altlarında, çoğu zaman onlarla birlikte listelenen ama listelenmemesi gereken ikinci bir aile durur: ReAct, Reflexion, plan-and-execute ve tree of thoughts reasoning loops’tur ve maliyetleri request’lerdedir.

Bölüm 12, modelin içindeki reasoning hakkındaydı; bunun bedelini tek call’da output tokens olarak ödersin. Bu diğer tür. Fatura geldiğinde fark önemlidir: daha uzun chain of thought tek call’u daha pahalı yapar; reasoning loop ise tek task’ı birçok call’a dönüştürür ve her biri kendinden önceki her şeyi yeniden gönderir — Bölüm 23’ün runaway table’ında ölçtüğü quadratic.

Tree-of-thoughts paper kendi cost table’ını yayımlar; bu olması gerekenden daha nadirdir. GPT-4 ile Game of 24 üzerinde: input/output prompting best-of-100, vaka başına $0.13 ile %33 çözdü; chain of thought best-of-100 $0.47 ile %49 çözdü; tree of thoughts $0.74 ile %74 çözdü ve yazarlar bunun “CoT’tan 5-100 kat daha fazla generated tokens gerektirebileceğini” not etti.⁷

Ucuz yöntemin fiyatının neredeyse altı katı, başarı oranının biraz fazla iki katı için. Bunun iyi bir alışveriş olup olmadığı, başarısız bir vakanın sana neye mal olduğuna bağlıdır — bu dördünden herhangi birini benimsemeden önce sorulacak soru.

Bu kurs onları yeniden implement etmez. Dördünün de kendi yazarları tarafından, Python’da reference implementation’ları var; değerleri bir çeviri değil kaynak olmalarında: ysymyth/ReAct, noahshinn/reflexion, princeton-nlp/tree-of-thought-llm ve AGI-Edgerunners/Plan-and-Solve-Prompting. O repositories’deki prompts’u oku; prompts paper’ların kendisidir.

Şimdi karışıklığın çoğunun yaşadığı gerçek multi-agent kısmına. Bir agent’ın başka bir agent’ı dahil etmesinin iki yolu vardır; bunlar variant değildir ve fark sonrasında kontrolün kimde olduğudur.

Tool olarak agent. Parent onu çağırır, bir cevap alır ve devam eder. Arkasında bütün bir agent bulunan Bölüm 18 tool interface’idir ve parent kontrolü asla kaybetmez. Yukarıdaki orchestrator’ın yaptığı budur.

Handoff. Parent konuşmayı devreder ve geri almaz. OpenAI’ın guide’ı yayımlanmış en net ifadedir: handoff’lar “bir agent’ın başka bir agent’a delegate etmesini sağlayan tek yönlü bir transferdir... Bir agent bir handoff function çağırırsa, en son conversation state’i de transfer ederken handoff edilen yeni agent üzerinde yürütmeyi hemen başlatırız.”⁸

Bir vocabulary uyarısı, çünkü insanlar sürekli burada takılıyor: “handoff” bir SDK’nın kelimesidir, standart değildir. OpenAI Agents SDK ve o guide’ın terminolojisidir; aynı guide iki arrangement’ı “manager” ve “decentralized” diye adlandırır ve manager pattern’de “edge’ler tool calls’ı, decentralized pattern’de ise edge’ler handoffs’u temsil eder” der.⁸ Bu alanda bir açık standart var — Linux Foundation telif hakkı altında, versioned release history ve documented breaking changes listesiyle 1.0.0 sürümündeki A2A; ifade edilen ilkesi opaque execution: agents “internal thoughts, plans veya tool implementations paylaşmaya ihtiyaç duymadan declared capabilities ve exchanged information’a dayanarak collaborate eder”.⁹ Bu bir handoff değildir ve karşılaştırma Bölüm 26’ya aittir. Burada önemli olan, iki kelimeden birinin bir library’nin API’si, diğerinin ise governance’a sahip bir specification olmasıdır.

Ayrım bir diyagram değil, data structure’dır:

export type EdgeKind = "tool" | "handoff";
export interface AgentEdge { from: string; to: string; kind: EdgeKind }
export interface AgentGraph { root: string; agents: Record<string, AgentSpec>; edges: AgentEdge[] }

/** One agent may not be both a tool of X and a handoff target of X. */
export function conflicts(g: AgentGraph): AgentEdge[] {
  const seen = new Map<string, EdgeKind>();
  const bad: AgentEdge[] = [];
  for (const e of g.edges) {
    const key = `${e.from}->${e.to}`;
    const other = seen.get(key);
    if (other && other !== e.kind) bad.push(e);                            
    else seen.set(key, e.kind);
  }
  return bad;
}

/** Every agent reachable from the root, and at what depth. */
export function reachable(g: AgentGraph): Map<string, number> {
  const depth = new Map([[g.root, 0]]);
  const queue = [g.root];
  while (queue.length) {
    const id = queue.shift()!;
    for (const e of g.edges.filter((x) => x.from === id)) {
      if (depth.has(e.to)) continue;
      depth.set(e.to, depth.get(id)! + 1);
      queue.push(e.to);
    }
  }
  return depth;
}

Yirmi satır, aksi hâlde production’da bulacağın iki bug. reachable kimsenin ulaşamadığı agent’ı bulur — configured, paid for, never called. conflicts aynı anda iki tür olan edge’i reddeder; kulağa pedantik gelir, ta ki yüksek sesle okuyana kadar: parent hem kontrolü korur hem de onu verir. Bir orphan ve bir double edge’e sahip beş agent’lı bir system üzerinde çalıştır:

reachable: lead@0 billing@1 tax@1 dunning@1
orphans:   ghost
conflicts: lead->tax

Şimdi bu section’ın var olma nedeni olan ölçüm ve bölümde scripted değil gerçek modele karşı alınmış tek ölçüm.

Bir müşteri ilk mesajında bir constraint belirtir — hesabımız İspanya’da değil Portekiz’de kayıtlı; vergiyle ilgili her şey Portekiz’i kullanmalı — başka bir şey hakkında sohbet eder, sonra billing’in yanıtlaması gereken bir soru sorar. Vaka transfer edilir. Yirmi dört trial, her seferinde farklı ülke ve şirket, dört transfer payload’u; receiving agent’a sonra tek soru sorulur: bu müşterinin hesabı hangi ülkede kayıtlı?

Üçüncü satır bir control ve control gibi davranır: bilgi orada yoktur, dolayısıyla hatırlanamaz. Diğer üçü bulgudur.

Full transcript 173 tokens ve zamanın %83’ünde çalışır; dört başarısızlığı bu bölümün değil Bölüm 24’ün konusudur. Typed record 69 tokens — summary’den yedi fazla — ve her seferinde çalışır, çünkü constraint bir cümlenin içinde değil named field’dadır.

Ve bakılması gereken satır summary’dir. 24’te 24 kez başarısız oldu ve nedeni reader’ın kaçırması değil. Constraint, 24 summary’nin yalnızca 1’inde hiç yer aldı. Receiving agent dikkatsiz değildi; cevabı içermeyen bir metin verildi. Summary, senin yazmadığın bir compaction’dır; göremediğin bir window’a sahip model tarafından üretilir, summary gibi okunmak için optimize edilir — ve “müşteri kayıtlarımızda yanlış ülke olduğunu söylüyor” tam da summariser’ın procedural noise diye düşürdüğü türden bir clause’dur.

Bu sayı için dürüst bir sınır: summariser yarım milyar parametreli bir model ve daha büyüğü daha fazlasını tutardı. Boyutla iyileşmeyen şey riskin şeklidir — sending agent, her handoff’ta, her phrasing’de, gözlemlenemez biçimde hangi bilgilerin hayatta kalacağına karar verir. Typed record bu yargıya hiç bağlı değildir; bu yüzden intelligence ile değil construction ile kazanır. Transferden sağ çıkması gereken her şey cümle değil field olmalı.

Aynı reasoning diğer yönde, agent-as-tool topology için de geçerlidir ve önceki tablo bunu zaten fiyatladı: bir worker’dan geri gelen de summary’dir ve yanında evidence almak için %8,3 daha fazla ödemek, parent tarafından görülen aynı düzeltmedir.

Üç kapanış gerçeği, hepsi yukarıdaki tablolardan.

Bir multi-agent system call’ları çoğaltır ve call’lar context içinde quadratic’tir. Orchestrator, tek agent’ın 5 model call yaptığı yerde 12 model call yaptı ve her biri kendi büyüyen transcript’ini taşır — 2.697’ye karşı 3.628 input tokens; task uzadıkça genişleyen bir fark.

Her boundary lossy channel’dır. İki agent bir summary demektir. Chain’de dört agent üç summary demektir; composed, her biri senin kararından başka bir şey için optimize eden bir model tarafından yazılmış.

Tek agent, kimsenin istemediği bir şeyi buldu. Purchase-order mismatch ortaya çıktı çünkü tek window fatura ve siparişi aynı anda tuttu. İşi uzmanlara bölmek, iki bilginin uyuşmadığını fark etme yeteneğini de böler.

Bunların hiçbiri published multi-agent frameworks’e karşı argüman değildir; tutorial’lar üzerinden değil primary sources olarak okumaya değerdirler.¹⁰ İkinci agent’ın yerini hak etmesi gerektiğini savunur.

Öyleyse tercih değil test. Şunlardan en az biri doğruysa ikinci bir agent ekle: sub-task, parent’ın inherit etmemesi gereken clean window gerektiriyorsa (Bölüm 24); sub-tasks gerçekten independent ise ve wall clock önemliyse, yukarıdaki 1,8× budur; sub-task different permissions veya farklı bir model gerektiriyorsa, Bölüm 30 bunu security argument’a dönüştürür; ya da sub-task başka biri tarafından owned ise, gerçek bir protocol burada önem kazanmaya başlar. Cevap “her agent’ın daha net prompt’u olsun diye” ise, tek agent’a daha net prompt ver. Ücretsizdir.

Artık beş pattern’i adlandırabilir, tek bir task üzerinde birbirlerine karşı fiyatlayabilir, orchestrator’ı sectioner’dan ve tool call’u handoff’tan ayırabilir, tek agent’ı bir tercih yerine tabloyla savunabilirsin.

Buradaki her arrangement, gerçek herhangi bir şeyle temas ettiğinde hayatta kalmayacak tek bir kolaylığı paylaştı: tüm tool’lar bize aitti. Fatura, sipariş, vergi tablosu, orchestrator’ın arkasındaki worker’lar — aynı repository, aynı deploy, aynı types, aynı insanlar.

Şimdi bunlardan birini şirket sınırının öbür tarafına koy. Vergi tablosu bir muhasebe vendor’ına, sipariş kaydı bir warehouse system’a ait; ikisi de senin Tool interface’ini okumadı. Yazmadığın bir modelin, başka birinin işlettiği bir capability’yi discover, describe ve call etmesi için bir yola ihtiyacın var — authentication (bu Bölüm 27’nin yarısı), versioning ve bir server’ın conversation’ının geri kalanını okuyamayacağı guarantee ile. Bu bir protocol problemidir, normative schema’ya sahip bir specification’ı vardır ve hakkında indexed olan neredeyse her şey artık var olmayan bir revision’ı anlatır.

Bölüm 26 bu specification’ı özetlemek yerine okur ve terminale elle JSON-RPC yazarak başlar.

Yukarıdaki her cost ve token count, ikinci section’da açıklanan scripted provider’dan geldi; Node 22 üzerinde loopback interface ile, o200k_base encoding kullanılarak sayıldı ve Bölüm 16’nın 6 Eylül 2026’da okuduğu rate’lerle fiyatlandı — milyon input tokens başına $2.00 ve milyon output başına $12.00. Wall-clock figures aynı run’lardan; provider latency call başına 400 ms ve tools 50 ms olarak ayarlandı, bu yüzden herhangi bir provider’ı değil arrangement’ı ölçerler. İki real-model measurement — handoff table ve voting-and-judging table — aynı şekle sahip bir endpoint arkasında CPU üzerinde float32’de Qwen/Qwen2.5-0.5B-Instruct kullandı; temperature belirtilen yerler dışında greedy, intervals Bölüm 4’ün Wilson method’u ile hesaplandı. Bu bölümde hiçbir request paid endpoint’e gitmedi ve içindeki hiçbir sayı estimate edilmedi.