เอเจนต์เขียนโค้ด AI โหลดบริบทของคุณล่วงหน้าอย่างไรและเมื่อใดที่มันย้อนกลับ

คุณเปิดเอดิเตอร์แล้วเริ่มเซสชัน ก่อนที่คุณจะพิมพ์อะไรสักตัว ก่อนที่เคอร์เซอร์จะนิ่งอยู่ในช่องพิมพ์ด้วยซ้ำ เอเจนต์ได้อ่านข้อมูลไปมากพอสมควรแล้ว มันรับเอาระบบพรอมต์ของตัวเอง คำนิยามของทุกเครื่องมือที่มันเรียกใช้ได้ คำสั่งกำหนดพฤติกรรม ไฟล์ CLAUDE.md ของโปรเจกต์คุณ (หรือ .cursorrules หรือ AGENTS.md) กฎที่ผูกกับพาธซึ่งมีผลบังคับใช้ และทุกอย่างที่อยู่ในไฟล์หน่วยความจำของมัน เมื่อถึงเวลาที่คุณพูดคำแรก เอเจนต์ก็มีแบบจำลองของคุณ ของโปรเจกต์คุณ และของวิธีที่มันควรจะทำตัวอยู่แล้ว

แบบจำลองความคิดแบบง่าย ๆ คือ คุณพิมพ์ เอเจนต์ตอบ แต่ลำดับจริงคือ เอเจนต์อ่านบริบทของคุณ แล้วคุณจึงพิมพ์ แล้วเอเจนต์จึงตอบ ขั้นแรกที่เงียบงันนั้น คือตอนที่เอเจนต์อ่านคุณก่อนที่คุณจะพูด และมันคือจุดที่ผลลัพธ์ของคุณถูกตัดสินไปแล้วมากอย่างน่าประหลาดใจ ส่วนหลักฐานว่าบริบทที่คุณป้อนให้มันช่วยได้จริงหรือไม่นั้น อึดอัดกว่าที่พวกเราส่วนใหญ่คิดกัน

เวอร์ชันสั้น

• เอเจนต์เขียนโค้ดด้วย AI จะโหลดบริบทที่เขียนไว้ล่วงหน้าก่อนข้อความแรกของคุณ ได้แก่ system prompt, คำนิยามเครื่องมือ และไฟล์คำสั่งเฉพาะเครื่องมือ เช่น CLAUDE.md, กฎของ Cursor, คำสั่ง GitHub Copilot หรือ AGENTS.md ในที่ที่รองรับหรือถูกนำเข้ามา คุณไม่ได้เป็นคนเริ่มบทสนทนา แต่เป็นการอ่านของเอเจนต์ต่างหาก
• การโหลดล่วงหน้านี้กินพื้นที่คอนเท็กซ์วินโดว์ที่ใช้ได้ไปมาก ตั้งแต่ก่อนที่คุณจะพิมพ์แม้แต่ตัวอักษรเดียว งบพื้นที่ทำงานจริงของคุณจึงเล็กกว่าที่ขนาดวินโดว์ตามที่โมเดลโฆษณาไว้บอกไว้
• ผลเชิงประจักษ์คือส่วนที่ขัดสามัญสำนึก ไฟล์บริบทที่นักพัฒนาเขียนเองช่วยได้เล็กน้อย (ความสำเร็จของงานราว +4%) โดยมีต้นทุนจริง (ค่าอนุมานราว +19%) ในขณะที่ไฟล์บริบทที่สร้างโดย LLM หรือคัดลอกมาวางอาจทำให้ผลลัพธ์ แย่กว่า.
• การโฮสต์โมเดลด้วยตนเองเปลี่ยนแปลงสิ่งที่คุณทำได้ ดู, ไม่ใช่สิ่งที่คุณต้อง do. สถาปัตยกรรมก่อนเซสชันเหมือนกันทุกที่ เครื่องมือในเครื่องเพียงแต่ให้คุณตรวจสอบและตรวจสอบบัญชีได้ วินัยในการเขียนบริบทที่คุณเข้าใจจริงๆ ไม่ได้หายไป

โมเดลแบบเรียบง่ายผิด: เอเจนต์อ่านก่อน

ลองนึกภาพช่วงเวลาที่เซสชัน Claude Code เริ่มต้นพอดี ระบบพรอมป์ถูกใส่เข้าไป นิยามของเครื่องมือถูกใส่เข้าไป จากนั้น ก่อนที่คุณจะพูดอะไรสักคำ ไฟล์ CLAUDE.md ของคุณก็ถูกส่งเข้าไป และรายละเอียดเชิงกลไกตรงนี้สำคัญ เอกสารของ Anthropic เองระบุชัดเจนว่า เนื้อหาของ CLAUDE.md “ถูกส่งมอบเป็นข้อความผู้ใช้หลังจาก system prompt,” โหลด “ที่จุดเริ่มต้นของทุกการสนทนา” ดังนั้นตาแรกของผู้ใช้ในบันทึกการสนทนาไม่ใช่คุณ มันคือไฟล์ของคุณที่พูดแทนคุณ กำหนดเงื่อนไขก่อนที่คุณจะมาถึง

สิ่งที่โหลดจริง ๆ ในช่วงเปิดเซสชันคือกองซ้อนทั้งชุด ได้แก่ ระบบพรอมต์ คำนิยามเครื่องมือ คำสั่งกำหนดพฤติกรรม ไฟล์คอนเท็กซ์ระดับโปรเจกต์และระดับผู้ใช้ของคุณ กฎที่ผูกกับพาธซึ่งตรงกับไฟล์ที่กำลังใช้งาน และไฟล์หน่วยความจำที่เอเจนต์ดูแลเอง ใน Claude Code ไฟล์คอนเท็กซ์จะถูกลำดับผ่านชั้นสี่ระดับ (นโยบายที่องค์กรจัดการ แล้วระดับผู้ใช้ (~/.claude/CLAUDE.md) แล้วระดับโปรเจกต์ (./CLAUDE.md) แล้วระดับโลคัล (./CLAUDE.local.md)) โดยต่อกันตามลำดับนั้น หน่วยความจำอัตโนมัติยังเพิ่มส่วนของตัวเองเข้ามาด้วย คือ 200 บรรทัดแรก (หรือ 25KB) ของไฟล์ MEMORY.md ที่เอเจนต์เขียนและอ่านเอง ซึ่งถูกโหลดทุกเซสชัน

ไม่มีอะไรในนี้ที่ฟรี ภาระของโครงสร้างพื้นฐาน (system prompt, คำนิยามเครื่องมือ, คำสั่งกำหนดพฤติกรรม) กินสัดส่วนใหญ่ของคอนเท็กซ์วินโดว์ที่ใช้ได้จริงตั้งแต่ก่อนที่ข้อความแรกของคุณจะไปถึงเสียอีก นั่นคือภาษีที่คุณจ่ายเพื่อให้เอเจนต์รู้ว่าจะเป็นเอเจนต์ได้อย่างไร และมันมองไม่เห็นเลยถ้าคุณไม่ไปตามหามันเอง

กำลังมีชื่อเรียกก่อตัวขึ้นรอบๆ วินัยในการจัดการทั้งหมดนี้ ทีม AI ประยุกต์ของ Anthropic เรียกมันว่า วิศวกรรมบริบท: “ชุดกลยุทธ์ในการคัดสรรและรักษาชุดโทเคน (ข้อมูล) ที่เหมาะที่สุดระหว่างการอนุมานของ LLM” เป็นคำที่มีประโยชน์ เพราะมันเปลี่ยนมุมมองต่อไฟล์ที่คุณเขียน จากโน้ตฝากถึงหุ่นยนต์ กลายเป็นการตัดสินใจเชิงสถาปัตยกรรมว่าอะไรจะเข้าไปกินทรัพยากรที่หายากและมีราคาแพง

สี่ Agent สี่วิธีในการอ่านคุณก่อน

เอเจนต์ไม่ได้อ่านคุณในแบบเดียวกันทั้งหมด พวกมันแบ่งตามสองแกนที่ควรกล่าวถึง: อะไร โหลดเมื่อเริ่มเซสชัน (ลำดับชั้นไฟล์ที่คัดสรร เทียบกับกฎที่เปิดตลอดเวลา เทียบกับการสแกนทั้ง repo), และ ว่าคุณสามารถตรวจสอบสิ่งนั้นได้มากแค่ไหน, กล่าวคือกลไกนั้นเป็นสิ่งที่ทำงานแบบตายตัวและตรวจสอบย้อนหลังได้ หรือเป็นดัชนีเชิงความหมายที่คุณต้องเชื่อไว้ก่อน สองแกนนี้เองคือจุดที่ Claude Code, Cursor, GitHub Copilot และ Aider ต่างกันจริง ๆ

การแบ่งของ Cursor นั้นให้บทเรียนมากที่สุด กฎของมันอยู่ในไฟล์ที่อ่านได้ซึ่งคุณควบคุม แต่มันยังสร้าง ดัชนีความหมายของ codebase ทั้งหมดของคุณ, vector embeddings ที่ขับเคลื่อนการค้นหา @codebase และที่คุณไม่สามารถตรวจสอบได้จริงๆ Aider อยู่ที่ปลายอีกด้าน: อ่าน git repository ทั้งหมดของคุณและสร้าง repo-map, แบบกำหนดผลได้แน่นอน โดยไม่มี embedding อยู่ตรงไหนเลย คุณตรวจสอบได้ชัดเจนว่าส่งอะไรเข้าไปให้โมเดลบ้าง เป็นการกลับด้านเชิงสถาปัตยกรรมแบบเดียวกัน แต่มองเห็นได้ต่างกันมาก สำหรับการเปรียบเทียบเครื่องมือแบบเจาะลึกทีละตัว เราได้เขียนถึงภูมิทัศน์ของ CLI แบบเอเจนต์ไว้ใน การประลอง agentic coding CLI ในภาพกว้าง และเผชิญหน้ากันโดยตรงใน OpenCode vs Claude Code ที่อื่น.

ใต้รูปแบบเฉพาะของแต่ละเครื่องมือ มาตรฐานกลางกำลังก่อตัวขึ้น AGENTS.md เกิดขึ้นทั่วระบบนิเวศเครื่องมือเอเจนต์ (OpenAI Codex, Amp, Jules จาก Google, Cursor และ Factory) และตอนนี้ ดูแลโดย Agentic AI Foundation ภายใต้ Linux Foundation, ถูกนำไปใช้ในรีโพซิทอรีกว่า 60,000 แห่ง นี่คือการยกระดับไฟล์บริบทก่อนเริ่มเซสชันจากความสะดวกเฉพาะเครื่องมือหนึ่ง ให้กลายเป็นสิ่งประดิษฐ์ระดับชั้นหนึ่งที่พกพาข้ามเครื่องมือได้ อุตสาหกรรมกำลังเห็นพ้องว่า “สิ่งที่เอเจนต์อ่านก่อนที่คุณจะพูด” สมควรมีมาตรฐานของตัวเอง

สิ่งที่หลักฐานบอกเกี่ยวกับว่าสิ่งเหล่านี้มีประโยชน์หรือไม่

นี่คือจุดที่เรื่องราวที่สบายใจพังทลาย ทีมงานจาก ETH Zurich (Gloaguen, Mündler, Müller, Raychev และ Vechev) ดำเนินการประเมินแบบควบคุม, “การประเมิน AGENTS.md,” ว่าไฟล์บริบทระดับที่เก็บโค้ดเหล่านี้ช่วยเพิ่มประสิทธิภาพของเอเจนต์เขียนโค้ดได้จริงหรือไม่ ตลอดเอเจนต์และโมเดลที่พวกเขาศึกษา ผลลัพธ์ไม่ใช่ทั้ง “ไฟล์บริบทได้ผล” และ “ไฟล์บริบทไม่ได้ผล” บทคัดย่อฉบับปัจจุบันระบุว่าไฟล์บริบทโดยทั่วไปไม่ได้ช่วยให้งานสำเร็จมากขึ้น และเพิ่มต้นทุนการอนุมานโดยเฉลี่ยมากกว่า 20% ในผลลัพธ์โดยละเอียดของงานวิจัย ไฟล์ที่นักพัฒนาเขียนเองเป็นข้อยกเว้น คือช่วยเพิ่มประสิทธิภาพราว 4% โดยเฉลี่ย แต่เพิ่มต้นทุนสูงถึง 19% ส่วนไฟล์ที่สร้างโดย LLM ไปในทิศทางตรงกันข้าม ลดประสิทธิภาพลงราว 3% โดยเฉลี่ย ขณะที่ดันต้นทุนขึ้นมากกว่า 20% ข้อค้นพบที่สามทำให้ภาพชัดขึ้น เอเจนต์เรียกใช้เครื่องมือบ่อยขึ้น 1.6-2.5 เท่าเมื่อเครื่องมือนั้นถูกระบุชื่อไว้ในไฟล์บริบท ซึ่งจะเป็นผลดีหรือผลเสียนั้นขึ้นอยู่กับว่าการเรียกเพิ่มเหล่านั้นมีเหตุผลรองรับหรือไม่ทั้งหมด

ลองหยุดคิดกับบรรทัดเรื่องไฟล์ที่ LLM สร้างขึ้นสักครู่ เพราะนี่คือบรรทัดที่รับน้ำหนักทั้งหมด ไฟล์ที่คุณไม่ได้เขียนเอง ไม่ว่าจะเกิดจากโมเดลสร้างให้ หรือดาวน์โหลดมาจากแพ็กของชุมชนที่รวม “คอนฟิก CLAUDE.md ที่ดีที่สุด” แล้วโยนลงในรีโปของคุณ ในสายตาของเอเจนต์มันอ่านเหมือนคำสั่งจากคนที่ไม่ได้รู้จักโค้ดเบสของคุณจริง ๆ ในโมเดลที่งานวิจัยทดสอบ ผลสุทธิคือติดลบ คุณจ่ายโทเค็นมากขึ้นเพื่อผลลัพธ์ที่แย่ลงเล็กน้อย บทความเกี่ยวกับ Augment Code ในเรื่องนี้สรุปไว้ได้ดี เมื่อเรียกผลลัพธ์ที่สะสมไว้ว่า “บริบทของเอเจนต์คุณคือลิ้นชักเก็บของสัพเพเหระ” ทุกคำสั่งที่ดูสมเหตุสมผลซึ่งคุณโกยใส่เข้าไปล้วนมีต้นทุน และคำสั่งที่คุณไม่ได้เขียนเองสำหรับโค้ดเบสที่มันไม่เข้าใจ มักมีต้นทุนสูงกว่าผลที่ได้กลับมา

ผมไม่ได้อ่านเรื่องนี้ว่า “ไฟล์บริบทเป็นสิ่งไม่ดี” และก็ไม่ได้อ่านว่า “ไฟล์บริบทเป็นสิ่งดี” กรอบคิดแบบสุดขั้วทั้งสองแบบนี้แหละที่พังทันทีเมื่อเจอข้อมูลจริง การอ่านแบบแคบลงคือ บริบทเป็นโครงสร้างพื้นฐานที่คุณออกแบบอย่างตั้งใจ และไฟล์ที่คุณไม่ได้เขียนเอง สำหรับโค้ดเบสที่มันไม่เข้าใจ คือต้นทุน ไม่ใช่ของขวัญ ข้อจำกัดเรื่องขอบเขตก็สำคัญเช่นกัน นี่คือสิ่งที่งานวิจัยพบสำหรับโมเดลและเอเจนต์ที่ทดสอบ ไม่ใช่กฎสากลของ LLM ทุกตัว แต่มันชี้ไปในทิศทางเดียวอย่างหนักแน่น และมีการยืนยันจากฝั่งผู้ให้บริการด้วย ทีม AI ประยุกต์ของ Anthropic เองได้ตั้งข้อสังเกตถึงการเปลี่ยนไปสู่การโหลดบริบท “ตอนที่ต้องใช้พอดี” ผ่านเครื่องมือขณะทำงาน แทนที่จะโหลดทุกอย่างไว้ล่วงหน้า และอธิบายแนวทางผสมที่ดึงข้อมูลบางส่วนไว้ล่วงหน้าแล้วสำรวจส่วนที่เหลือขณะทำงาน เมื่อบริษัทที่ปล่อย CLAUDE.md ออกมาเองยังเอนไปทางโหลดล่วงหน้าให้น้อยลง สัญชาตญาณที่จะคัดลอกไฟล์บริบทก้อนใหญ่มาวางก็สมควรถูกทบทวนอีกครั้ง

ข้อสรุปของส่วนนี้: ผู้เขียนคือสัญญาณที่บอกได้ว่าคอนเท็กซ์จะคุ้มค่าหรือไม่ ต้นทุนโทเค็นเท่ากันทั้งสองทาง สิ่งที่เปลี่ยนผลตอบแทนคือคำสั่งนั้นมาจากคนที่รู้จักโค้ดเบสจริงๆ หรือไม่

บริบทที่จางหายไป: ทำไมการเริ่มต้นเซสชันจึงไม่ใช่เรื่องราวทั้งหมด

การพรีโหลดเป็นตัวกำหนดข้อจำกัด แต่ไม่ได้รักษาข้อจำกัดนั้นไว้ สิ่งที่นักพัฒนาเจอซ้ำๆ คือครึ่งหลังของเรื่องนี้: คอนเท็กซ์ที่คุณจัดวางอย่างพิถีพิถันตอนเริ่มเซสชันจะค่อยๆ สึกกร่อนไปเมื่อเซสชันดำเนินต่อ และมันเกิดขึ้นอย่างเงียบๆ

วิธีที่มีประโยชน์ในการจินตนาการเรื่องนี้มาจากกรอบแนวคิดของทีม Mem0 ที่ว่า หน้าต่างบริบทคือ RAM ไม่ใช่พื้นที่จัดเก็บ ที่ชั่วคราวและมีขอบเขตจำกัด ไม่ใช่ที่พำนักถาวรของคำสั่งคุณ โหลดอะไรเข้าไปตอนเริ่มต้นมันก็อยู่ตรงนั้น แต่ถ้าคุยต่อไปนาน ๆ โดยไม่ได้เรียกใช้มัน มันก็จะจางหายไป เหมือนตัวแปรที่คุณเลิกอ้างถึงแล้วสุดท้ายก็ถูกเขียนทับ นี่คือกลไกเบื้องหลังรูปแบบที่นักวิจัยเรียกว่าการเสื่อมของคำสั่ง การศึกษาปี 2026 โดย Gamage และเพื่อนร่วมงาน พบว่าข้อกำหนดแบบห้ามทำนั้นเปราะบางเป็นพิเศษ ในสภาพแวดล้อมทดสอบหนึ่ง การปฏิบัติตามลดลงจาก 73% ที่เทิร์นที่ 5 เหลือราว 33% เมื่อถึงเทิร์นที่ 16 นี่เป็นผลจากห้องทดลอง ไม่ใช่ค่าคงที่สากล แต่ตรงกับสิ่งที่หลายคนรู้สึกว่าเกิดขึ้นในเซสชันยาว ๆ

ขอบเขตของเซสชันคือจุดที่มันชัดเจนขึ้น นักพัฒนาในการอภิปราย Hacker News รายงานว่าซับเอเจนต์ที่ถูกสร้างขึ้นอาจเจอปัญหาการส่งต่อคอนเท็กซ์ ดังนั้นงานที่ส่งต่อกลางทางอาจมาถึงพร้อมคอนเท็กซ์จากเซสชันหลักน้อยกว่าที่คุณคิด และเวลาที่ปล่อยว่างก็มีต้นทุนของมันเอง: ในเธรดที่ Boris Cherny จาก Anthropic แสดงความคิดเห็น การสนทนาครอบคลุมว่าเซสชันที่ทิ้งไว้เฉย ๆ สามารถกระตุ้นการสร้างใหม่ครั้งใหญ่จากการพลาดแคชได้อย่างไร เป็นหลักแสนโทเคน โดยไม่มีการเตือนคุณเลย แก่นที่ชุมชนรายงานซ้ำ ๆ คือความเงียบ การบีบอัดทำงาน เหตุผลก่อนหน้าถูกตัดทิ้ง คุณภาพตก และไม่มีอะไรบนหน้าจอบอกคุณว่าเกิดขึ้นแล้ว คุณแค่สังเกตว่าผลลัพธ์แย่ลง

การโฮสต์ด้วยตนเองให้การควบคุมมากขึ้นหรือไม่?

รันทั้งหมดด้วยตัวเอง (Ollama ร่วมกับ Open WebUI หรือเอเจนต์อย่าง Aider หรือ Continue.dev ที่ชี้ไปยังโมเดลในเครื่อง) แล้วคำตอบที่ตรงไปตรงมาสำหรับคำถาม “ตอนนี้ฉันควบคุมได้มากขึ้นไหม” คือ สิ่งที่คุณได้มากขึ้นคือ การมองเห็น, ไม่ใช่การควบคุมโดยเนื้อแท้มากขึ้น ความแตกต่างนี้คือประเด็นสำคัญ

สิ่งที่การโฮสต์เองมอบให้คุณจริง ๆ คือการตรวจสอบได้ ไม่มีข้อมูลบทสนทนาใดออกไปนอกโครงสร้างพื้นฐานของคุณ คุณอ่านระบบพรอมต์ฉบับเต็มได้ แทนที่จะต้องเชื่อพรอมต์ปิดของผู้ให้บริการ เมื่อใช้เครื่องมือแบบกำหนดผลแน่นอนอย่าง Aider คุณตรวจสอบได้อย่างแม่นยำว่าอะไรเข้าไปในการเรียกโมเดลแต่ละครั้ง repo-map เป็นสิ่งที่อ่านได้ ไม่ใช่กล่องดำเชิงความหมายอย่างดัชนี embedding ของ Cursor สำหรับใครก็ตามที่ใส่ใจเรื่องการตรวจสอบย้อนกลับและการทำซ้ำได้ ใส่ใจว่าจะตอบได้ไหมว่า “เอเจนต์เห็นอะไรจริง ๆ” ความสามารถในการตรวจสอบนี้เป็นของจริง และไม่ใช่เรื่องเล็ก

แต่การพลิกกลับเชิงสถาปัตยกรรมนี้ไม่สนใจว่าโมเดลรันอยู่ที่ไหน ไม่ว่าคุณจะใช้โมเดลในเครื่องผ่าน Ollama ใช้ Claude Code ที่ต่อกับ API บนคลาวด์ หรือใช้ Cursor แบบสมัครสมาชิก เอเจนต์ก็ยังอ่านบริบทก่อนเริ่มเซสชันก่อนที่คุณจะพูด และคุณก็ยังต้องออกแบบบริบทนั้นอย่างตั้งใจอยู่ดี วินัยที่ต้องใช้เหมือนกันทุกประการ การโฮสต์เองมอบหน้าต่างที่ชัดขึ้นให้คุณมองเห็นกลไก แต่ไม่ได้มอบกลไกที่ต่างออกไป และแน่นอนว่าไม่ได้ยกเว้นคุณจากบทเรียนของ ETH Zurich เรื่องสิ่งที่เกิดขึ้นเมื่อคุณโหลดบริบทที่คุณไม่ได้เขียนเอง ดังนั้นสิ่งเดียวที่ควรเปลี่ยนจากเรื่องทั้งหมดนี้คือ เลิกมองไฟล์บริบทเป็นของขวัญที่คุณยื่นให้เอเจนต์ แล้วเริ่มมองมันเป็นโครงสร้างพื้นฐานที่มีค่าใช้จ่ายเดินอยู่ตลอด เขียนเฉพาะสิ่งที่คุณเข้าใจจริง ๆ เกี่ยวกับโค้ดเบส โหลดให้น้อยเข้าไว้แทนที่จะโหลดให้มาก และจำไว้ว่าเอเจนต์อ่านคุณก่อน ฉะนั้นเวอร์ชันของคุณที่มันอ่านควรเป็นเวอร์ชันที่คุณยืนยันได้อย่างเต็มปาก

คำถามที่พบบ่อย

เอเจนต์เขียนโค้ด AI อ่านไฟล์ของคุณก่อนที่คุณจะพิมพ์อะไรก็ตามหรือไม่?

ใช่ เมื่อเริ่มเซสชัน เอเจนต์เขียนโค้ด AI จะโหลดพรอมป์ตระบบ นิยามเครื่องมือ และไฟล์คอนเท็กซ์ของคุณ (CLAUDE.md, .cursorrules หรือ AGENTS.md) พร้อมกับ repo-map หรือไฟล์ความจำใด ๆ ทั้งหมดนี้เกิดขึ้นก่อนข้อความแรกของคุณ โดยเฉพาะใน Claude Code ไฟล์ CLAUDE.md จะถูกส่งเป็นข้อความของผู้ใช้ทันทีหลังพรอมป์ตระบบ บทสนทนาจึงเริ่มต้นด้วยไฟล์ของคุณแทนที่จะเป็นตัวคุณเอง

ไฟล์บริบทอย่าง CLAUDE.md ปรับปรุงประสิทธิภาพของเอเจนต์จริงๆ ไหม?

บางส่วน และน้อยกว่าที่คนส่วนใหญ่คิด ใน การประเมินไฟล์สไตล์ AGENTS.md ของ ETH Zurich, บทคัดย่อฉบับปัจจุบันระบุว่าไฟล์บริบทโดยทั่วไปไม่ได้ช่วยให้ทำงานสำเร็จมากขึ้น และเพิ่มต้นทุนการอนุมานโดยเฉลี่ยมากกว่า 20% ผลลัพธ์แบบละเอียดมีประโยชน์กว่าสำหรับผู้ใช้งานจริง ไฟล์ที่นักพัฒนาเขียนเองช่วยเพิ่มประสิทธิภาพเฉลี่ยราว 4% แต่เพิ่มต้นทุนสูงถึง 19% ขณะที่ไฟล์ที่สร้างโดย LLM ลดประสิทธิภาพเฉลี่ยราว 3% และเพิ่มต้นทุนมากกว่า 20% อ่านเชิงปฏิบัติได้ว่า ไฟล์ที่คุณเขียนเองและเข้าใจอาจช่วยได้เล็กน้อย ส่วนไฟล์ที่คุณไม่ได้เขียนอาจทำให้คุณเสียต้นทุนอย่างเงียบ ๆ

ขนาดเท่าใดของหน้าต่างบริบทที่ถูกใช้ก่อนที่จะส่งข้อความ?

สัดส่วนที่มากพอสมควร system prompt, คำนิยามเครื่องมือ และคำสั่งกำหนดพฤติกรรมจะถูกโหลดก่อนที่ผู้ใช้จะพิมพ์อะไร และรวมกันแล้วกินพื้นที่คอนเท็กซ์วินโดว์ที่ใช้ได้จริงไปไม่น้อย งบพื้นที่ทำงานที่คุณใช้ได้จริงจึงเล็กกว่าคอนเท็กซ์วินโดว์ที่โมเดลโฆษณาไว้ เพราะภาระคงที่ตอนเริ่มต้นนี้

การโฮสต์โมเดล AI เองให้คุณควบคุมบริบทได้มากขึ้นหรือไม่?

ได้ความโปร่งใสมากขึ้น ไม่ใช่อำนาจควบคุมโดยเนื้อแท้ที่มากขึ้น การโฮสต์เองทำให้คุณตรวจดู system prompt ได้ทั้งหมด เก็บข้อมูลบทสนทนาไว้บนโครงสร้างพื้นฐานของคุณเอง และ (เมื่อใช้เครื่องมือแบบกำหนดผลได้อย่าง Aider) ตรวจสอบได้ว่ามีอะไรถูกส่งเข้าไปในแต่ละคำเรียกบ้าง แต่สถาปัตยกรรมของบริบทก่อนเริ่มเซสชันก็เหมือนกับในเครื่องมือบนคลาวด์ และคุณยังต้องออกแบบบริบทของคุณอย่างตั้งใจอยู่ดี

AGENTS.md คืออะไร?

AGENTS.md เป็นรูปแบบเปิดสำหรับบอกเอเจนต์เขียนโค้ดว่าจะทำงานกับโค้ดเบสอย่างไร เทียบได้กับ README เวอร์ชันที่เขียนถึงเอเจนต์ รูปแบบนี้เกิดขึ้นทั่วระบบนิเวศเครื่องมือเอเจนต์ (OpenAI Codex, Amp, Jules จาก Google, Cursor และ Factory) และตอนนี้อยู่ในการดูแลของ Agentic AI Foundation ภายใต้ Linux Foundation โดยมีการใช้งานในรีโพซิทอรีกว่า 60,000 แห่ง จึงกลายเป็นมาตรฐานข้ามเครื่องมือที่กำลังก่อตัวขึ้นสำหรับบริบทของเอเจนต์ก่อนเริ่มเซสชัน