فکر کن، انجام بده، نگاه کن، تکرار کن

از عاملی می‌خواهید «تستِ خراب را درست کن». بیست دقیقه بعد کار تمام است: تست‌ها را اجرا کرد، سه فایل خواند، یکی را تغییر داد، تست‌ها را دوباره اجرا کرد، خطایی تازه دید، فایلِ دیگری را تغییر داد و بارِ سوم تست‌ها را اجرا کرد. هیچ‌کس هیچ‌کدام از این گام‌ها را به او نگفته بود. در درس قبل یک فراخوانی ابزار را دیدید. این درس درباره‌ی چیزی است که یک فراخوانی را به بیست تبدیل می‌کند.

حلقه

پاسخ به‌طرزِ شگفت‌آوری کوچک است. برنامه‌ی دورِ مدل یک چرخه را تکرار می‌کند:

1. درخواست را برای مدل بفرست.
2. اگر پاسخ ابزار خواسته، آن‌ها را اجرا کن، نتیجه‌ها را به گفت‌وگو اضافه کن و به گامِ ۱ برگرد.
3. اگر پاسخ هیچ ابزاری نخواسته، همان پاسخِ نهایی است: نشانش بده و بایست.

این حلقه‌ی عامل (agent loop) است. این هم شکلِ آن به پایتون. برای دنبال کردنش لازم نیست پایتون بلد باشید:

messages = [your_request]
while True:
    reply = model.respond(system_prompt, tools, messages)
    messages.append(reply)
    if not reply.tool_calls:
        break
    results = [run_tool(call) for call in reply.tool_calls]
    messages.append(results)
print(reply.text)

خط‌به‌خط: گفت‌وگو را با درخواستِ شما شروع کن. بعد بارها و بارها (while True): همه‌چیز را برای مدل بفرست و پاسخش را به گفت‌وگو اضافه کن. اگر پاسخ هیچ فراخوانی ابزاری ندارد، از حلقه بیرون برو (break): کارِ مدل تمام است. وگرنه هر ابزاری را که خواسته اجرا کن، نتیجه‌ها را به گفت‌وگو اضافه کن و دوباره دور بزن. در آخر، کلمه‌های پایانیِ مدل را نشان بده.

به هر دورِ حلقه یک نوبت (turn) یا یک گام (step) می‌گویند. دقت کنید چه کسی تصمیم می‌گیرد کی بایستد: نه برنامه، بلکه خودِ مدل، با نوشتنِ پاسخی که هیچ فراخوانی ابزاری ندارد.

لیلا همین؟ فکر می‌کردم عامل یک برنامه‌ی عظیم و پیچیده است.

امید بخشِ هوشمند مدل است. حلقه فقط صبور است. حلقه چه چیزی به مدل می‌دهد که یک پرسش و پاسخِ تنها نمی‌دهد؟

لیلا فرصتِ اینکه ببیند چه شد. می‌تواند چیزی را امتحان کند، نتیجه را ببیند و نظرش را عوض کند.

امید دقیقاً. فکر کن یک فرمولِ خرابِ صفحه‌گسترده را چطور درست می‌کنی. راه‌حل را می‌نویسی بی‌آنکه هرگز نتیجه را نگاه کنی؟

لیلا نه. امتحان می‌کنم، نگاه می‌کنم و دوباره امتحان می‌کنم. پس حلقه به مدل اجازه می‌دهد همان‌طور کار کند که آدم‌ها کار می‌کنند.

امید و برای همین عامل‌ها در کارهای واقعی خیلی بهتر از یک پاسخِ تنها هستند: در هر نوبت شاهدی می‌گیرند که آیا در مسیرِ درست‌اند یا نه.

لیلا ولی هر نوبت دوباره همه‌چیز را می‌فرستد، نه؟ کلِ گفت‌وگو، هر فایلی که خوانده...

امید هر نوبت. بیست نوبت یعنی بیست درخواستِ کامل، که هر کدام کمی بلندتر از قبلی است.

یک جلسه، نوبت‌به‌نوبت

این هم «تستِ خراب را درست کن»، به شکلِ همان نوارِ نوبت‌هایی که واقعاً هست:

از این تصویر چند چیز روشن می‌شود:

• هر نوبت یک درخواستِ کامل است. هزینه و زمینه با هر نوبت بزرگ‌تر می‌شوند، همان‌طور که در درس‌های «پرداخت برای هر توکن» و «هر آنچه مدل می‌بیند» دیدید.
• یک نوبت می‌تواند چند ابزار را با هم بخواهد. اگر مدل بخواهد سه فایل را بخواند، می‌تواند هر سه را در یک پاسخ بخواهد و برنامه آن‌ها را کنارِ هم اجرا می‌کند. این کار نوبت‌ها را کم می‌کند.
• نتیجه‌ها گامِ بعدی را هدایت می‌کنند. همان خطای تازه در نوبتِ پنجم بود که مدل را واداشت فایلِ دوم را ویرایش کند. هیچ‌کس از پیش برایش برنامه نریخته بود.

چطور تمام می‌شود

چنین حلقه‌ای به یکی از سه راه تمام می‌شود:

• مدل به این نتیجه می‌رسد که کار تمام است، و پاسخی نهایی بدونِ فراخوانی ابزار می‌نویسد. راهِ معمول همین است.
• به سقفی می‌رسد که برنامه گذاشته است: بیشترین تعدادِ نوبت، یک محدودیتِ زمانی یا یک بودجه.
• شما متوقفش می‌کنید. در Claude Code، زدنِ کلیدِ Escape عامل را همان لحظه قطع می‌کند و می‌توانید بگویید چه کارِ دیگری بکند.

برای همین است که عامل‌ها می‌توانند یک ساعت یا بیشتر روی یک کارِ بزرگ کار کنند: تا وقتی مدل ابزار بخواهد، حلقه ادامه دارد. و برای همین است که عامل‌ها گاهی دورِ خودشان می‌چرخند: همان راه‌حلِ ناموفق را امتحان می‌کنند یا همان فایل‌ها را دوباره می‌خوانند. حلقه نمی‌داند گیر کرده است؛ فقط مدل می‌تواند متوجه شود، و گاهی نمی‌شود.

امتحان کنید

کاری کوچک که بررسی‌ای در آن هست به یک عامل بدهید، مثلاً «فایلی به نامِ notes.txt بساز که تاریخِ امروز در آن باشد، و بعد آن را بخوان تا مطمئن شوی». نوبت‌ها را در آنچه نشانتان می‌دهد بشمارید: فراخوانی‌های ابزار، و بعد پاسخِ نهایی. اگر عاملی ندارید، ویدیویی از کار با یک عامل در اینترنت پیدا کنید و گام‌هایش را بشمارید.

درست به کار بردن

1. راهی برای بررسیِ کار به عامل بدهید. تست‌هایی برای اجرا، صفحه‌ای برای نگاه کردن، عددی برای مقایسه: حلقه فقط به خوبیِ شاهدی است که هر نوبت برمی‌گرداند.
2. وقتی دورِ خودش می‌چرخد، دخالت کنید. اگر دیدید همان تلاش دو بار تکرار شد، متوقفش کنید و چیزی را که کم دارد بگویید. یک جمله از شما می‌تواند جلوی بیست نوبتِ بیهوده را بگیرد.
3. اندازه‌ی کارها را معقول نگه دارید. کاری که ۲۰۰ نوبت لازم دارد زمینه را شلوغ می‌کند و گران تمام می‌شود؛ آن را به تکه‌هایی تقسیم کنید که هر کدام با چیزی قابلِ بررسی تمام شوند.

واژه‌های این درس

• حلقه‌ی عامل (agent loop) - چرخه‌ای که عامل اجرا می‌کند: درخواست را بفرست، هر ابزاری را که پاسخ خواسته اجرا کن، نتیجه‌ها را اضافه کن، و تکرار کن تا پاسخی هیچ ابزاری نخواهد
• نوبت (turn) - یک دورِ حلقه: یک درخواست به مدل و پاسخش؛ به آن گام (step) هم می‌گویند

ایده‌ی اصلی

عامل یعنی مدلی در یک حلقه: بخواه، انجام بده، نتیجه را ببین، تکرار کن، تا مدل بگوید کار تمام است. حلقه ساده است؛ قدرتش از شاهدی است که در هر نوبت به مدل می‌دهد، و هزینه‌اش از اینکه هر بار همه‌چیز را دوباره می‌فرستد.