เหตุใด AI Coding Agent จึงใช้ Rust และ Python ร่วมกัน
รายละเอียดที่เปิดเผยมากที่สุดประการหนึ่งใน repo Claw Code parity สาธารณะไม่ใช่เกณฑ์มาตรฐานหรือภาพหน้าจอของผลิตภัณฑ์
มันคือการแบ่งแยกภาษา
โปรเจ็กต์ไม่ได้พยายามทำทุกอย่างในเลเยอร์เดียว แต่จะเผยให้เห็นรูปแบบที่ทีมโครงสร้างพื้นฐาน AI มีแนวโน้มที่จะนำมาใช้ในอีกไม่กี่ปีข้างหน้า:
Rust สำหรับรันไทม์คอร์, Python สำหรับการเรียบเรียง ความเข้ากันได้ และงานการย้ายข้อมูล
การแยกนั้นไม่ใช่โรงละครวิศวกรรมที่ทันสมัย
เป็นคำตอบที่เป็นประโยชน์สำหรับปัญหายุ่งวุ่นวาย
แผนที่ซีรีส์
บทความนี้เป็นส่วนหนึ่งของ ภายใน AI Coding Agent Stack:
- รหัส Claw เปิดเผยอะไรเกี่ยวกับสถาปัตยกรรมตัวแทนการเข้ารหัส AI
- เหตุใด AI Coding Agent จึงใช้ Rust และ Python ร่วมกัน
- เครื่องมือ สิทธิ์ และ MCP: วิธีที่ตัวแทนการเข้ารหัสกลายเป็นจริง
- Hooks, Plugins และ Sessions ใน AI Coding Agents
- การเขียนซ้ำในห้องสะอาดและการตรวจสอบความเท่าเทียมกันสำหรับทีมตัวแทน AI
เหตุใดภาษาหนึ่งจึงมักหยุดการขยายขนาด
ในขั้นตอนต้นแบบ ภาษาเดียวก็สะดวก
ในขั้นตอนตัวแทน ข้อดีข้อเสียจะเปลี่ยนไป
ตอนนี้คุณต้องสร้างสมดุล:
- การทดลองที่รวดเร็วและเวิร์กโฟลว์
- ระบบไฟล์และการเข้าถึงเชลล์
- ความคงอยู่ของเซสชัน
- สตรีมมิ่งรุ่น IO
- การบังคับใช้สิทธิ์
- การรวมเครื่องมือภายนอก
- ความน่าเชื่อถือในระยะยาว
- แรงกดดันในการโยกย้ายจากระบบเก่า
การพยายามเพิ่มประสิทธิภาพทั้งหมดด้วยภาษาเดียวมักจะสร้างระบบที่ไม่สมดุล รันไทม์หลวมเกินไป หรือเลเยอร์การวนซ้ำแข็งเกินไป
Claw Code Parity Repo แสดงให้เห็นถึงการประนีประนอมที่มีระเบียบวินัยมากขึ้น
สิ่งที่สนิมกำลังทำอยู่ในกอง
พื้นที่ทำงานของ Rust คือจุดที่ระบบเริ่มจริงจัง
ตั้งแต่วันที่ 2 เมษายน 2026 เป็นต้นไป Public Parity Repo จะเปิดเผยพื้นที่ทำงานของ Rust พร้อมกล่องสำหรับ:
apicommandscompat-harnesspluginsruntimerusty-claude-clitelemetrytools
นั่นจะบอกคุณได้อย่างชัดเจนว่าผู้เขียนต้องการการรับประกันอย่างหนักที่ไหน
Rust กำลังจัดการชิ้นส่วนของผลิตภัณฑ์ที่ความสามารถในการคาดการณ์มีความสำคัญที่สุด:
- ไบนารี CLI และการแยกวิเคราะห์อาร์กิวเมนต์
- รันไทม์การสนทนา
- คำจำกัดความของเครื่องมือและการดำเนินการ
- โหมดการอนุญาต
- ตะขอ
- การขนส่ง MCP และการจัดการเซิร์ฟเวอร์
- การประปา OAuth และ API
- การติดตามการใช้งานและระบบโทรมาตร
กล่าวอีกนัยหนึ่ง Rust เป็นเจ้าของขอบเขตความไว้วางใจ
นั่นสมเหตุสมผลแล้ว
หากตัวแทนของคุณสามารถอ่านไฟล์ แก้ไขโค้ด กระบวนการวางไข่ เชื่อมต่อกับบริการระยะไกล และดำเนินการเซสชันที่มีอายุการใช้งานยาวนานต่อได้ ลักษณะการทำงานของรันไทม์จะไม่ใช่รายละเอียดการใช้งานทั่วไปอีกต่อไป มันคือผลิตภัณฑ์
Python กำลังทำอะไรอยู่ในสแต็ก
ฝั่ง Python มีขนาดเล็กกว่า แต่มีความสำคัญเชิงกลยุทธ์
มันไม่ได้พยายามที่จะเป็นรันไทม์สุดท้าย มันทำหน้าที่เหมือน มิเรอร์และเลเยอร์การโยกย้าย
แผนผังสาธารณะ src/ มีคำสั่งดังนี้:
summarymanifestparity-auditbootstraprouteturn-loop
นอกจากนี้ยังจัดส่งโมดูลที่สนับสนุนสแน็ปช็อตสำหรับรายการคำสั่งและเครื่องมือ รวมถึงการทดสอบที่ตรวจสอบรูปร่างและพฤติกรรมของพื้นที่ทำงาน Python
นั่นไม่ใช่งานเดียวกับรันไทม์ของ Rust
Python กำลังทำสิ่งที่ Python มักจะทำได้ดีที่สุดในโค้ดเบสที่มีอินฟาเรดหนัก:
- ทำซ้ำอย่างรวดเร็ว
- การสร้างรายงาน
- สินค้าคงคลังและงานรายการ
- แผ่นชิมความเข้ากันได้
- กาวเวิร์กโฟลว์
- นั่งร้านอพยพ
นี่คือเลเยอร์ประเภทที่คุณต้องการเมื่อมีการนำระบบไปใช้ใหม่หรือกำหนดรูปแบบใหม่ในที่สาธารณะ โดยจะรักษาการมองเห็นในขณะที่รันไทม์ระดับล่างพัฒนาขึ้น
รูปแบบสถาปัตยกรรมที่ซ่อนอยู่ในสายตาธรรมดา
นี่เป็นวิธีที่สะอาดกว่าในการวางเฟรมการแยก:
Rust
-> execution core
-> safety and permissions
-> sessions, hooks, MCP, CLI runtime
Python
-> parity mapping
-> inventories and manifests
-> migration reports
-> compatibility-oriented workflow logicแผนกดังกล่าวมีประโยชน์เนื่องจากจะรักษาพฤติกรรมที่คำนึงถึงความปลอดภัยมากที่สุดไว้ใกล้กับการรับประกันรันไทม์ที่แข็งแกร่งที่สุด ขณะเดียวกันก็รักษาพื้นผิวที่ยืดหยุ่นมากขึ้นสำหรับงานทำซ้ำและการแปล
รูปแบบนี้มีแนวโน้มที่จะปรากฏนอกเหนือจาก Claw Code
ฉันคาดหวังว่าจะมีทีมจำนวนมากที่สร้างตัวแทนการเขียนโค้ด เจ้าหน้าที่รักษาความปลอดภัย และตัวแทนระบบอัตโนมัติมารวมตัวกันเพื่อสิ่งที่คล้ายกัน:
- ภาษาหนึ่งสำหรับเคอร์เนลการดำเนินการ
- อีกรายการหนึ่งสำหรับการจัดเตรียม การทดลอง หรือการโยกย้าย
คู่ที่แน่นอนอาจแตกต่างกัน ตรรกะพื้นฐานอาจจะไม่
เหตุใดจึงสมเหตุสมผลสำหรับระบบ AI โดยเฉพาะ
ผลิตภัณฑ์ตัวแทนนั้นไม่ธรรมดาเพราะอาศัยอยู่ที่จุดตัดของสามโลก:
- การทำซ้ำผลิตภัณฑ์
- วิศวกรรมระบบรันไทม์
- การโยกย้ายและความเข้ากันได้
Python ยังคงยอดเยี่ยมสำหรับตัวแรกและตัวที่สาม
สนิมมีความยอดเยี่ยมมากขึ้นเรื่อย ๆ ในวินาทีนี้
เมื่อคุณยอมรับแล้ว การออกแบบแบบไฮบริดจะหยุดดูเหมือนเป็นความไม่แน่ใจ และเริ่มดูเหมือนเป็นความเชี่ยวชาญเฉพาะทาง
โดยเฉพาะอย่างยิ่งสำหรับเอเจนต์การเขียนโค้ด โดยที่ระบบอาจ:
- ดำเนินการคำสั่งเชลล์
- แก้ไขไฟล์จำนวนมากตามลำดับ
- เหตุการณ์เครื่องมือสตรีม
- จัดการสถานะเซสชันเป็นระยะเวลานาน
- บังคับใช้ขอบเขตความไว้วางใจของมนุษย์
ข้อผิดพลาดรันไทม์ที่สำคัญในสภาพแวดล้อมนั้นไม่ใช่เรื่องสวยงาม เป็นปัญหาด้านผลิตภัณฑ์และความปลอดภัย
ที่ทีมเข้าใจผิดสิ่งนี้
แน่นอนว่าสแต็กหลายภาษาอาจทำงานได้ไม่ดีอย่างรวดเร็ว
โหมดความล้มเหลวไม่ใช่ "มีภาษามากเกินไป"
โหมดความล้มเหลวคือ ความเป็นเจ้าของที่ไม่ชัดเจน
คุณจะประสบปัญหาเมื่อ:
- ทั้งสองเลเยอร์ใช้พฤติกรรมเดียวกันต่างกัน
- ขอบเขตไม่มีเอกสาร
- การทดสอบครอบคลุมเพียงด้านเดียว
- ตรรกะการโยกย้ายกลายเป็นตรรกะการผลิตอย่างเงียบ ๆ
- โค้ดวิกฤตรันไทม์รั่วไหลกลับเข้าไปในเลเยอร์การเขียนสคริปต์
นั่นคือเหตุผลที่ฉันคิดว่ารสชาติการรายงานความเท่าเทียมกันของฝั่ง Python มีความสำคัญมากที่นี่ มันบ่งบอกถึงความตั้งใจ เลเยอร์นี้มีไว้เพื่ออธิบาย จำลอง และช่วยจัดการการเปลี่ยนแปลง ไม่ให้กลายเป็นรันไทม์ที่สองโดยไม่ได้ตั้งใจ
สัญญาณอุตสาหกรรมที่กว้างขึ้น
นอกจากนี้ยังสอดคล้องกับรูปแบบที่กว้างขึ้นในเครื่องมือ AI
ตลาดกำลังแยก "เลเยอร์พร้อมท์" ออกจาก "เลเยอร์ปฏิบัติการ" อย่างช้าๆ
เลเยอร์พร้อมท์มีความยืดหยุ่นและเคลื่อนไหวรวดเร็ว
ความต้องการชั้นปฏิบัติการ:
- การค้ำประกันที่แข็งแกร่งยิ่งขึ้น
- ความสามารถในการสังเกตที่ดีขึ้น
- พฤติกรรมการทำงานพร้อมกันที่สะอาดยิ่งขึ้น
- การใช้เครื่องมือที่ปลอดภัยยิ่งขึ้น
- เส้นทางการตรวจสอบที่ชัดเจนยิ่งขึ้น
นั่นเป็นส่วนหนึ่งของเหตุผลว่าทำไมเราจึงเห็นการเปลี่ยนแปลงความสนใจอย่างมากจากคุณภาพของโมเดลล้วนๆ ไปสู่โครงสร้างพื้นฐานของตัวแทน ค่าที่ลึกกว่านั้นกำลังเคลื่อนเข้าสู่การออกแบบรันไทม์ ไม่ใช่แค่การสร้างโทเค็นเท่านั้น
หากคุณต้องการมุมมองผลิตภัณฑ์ในกะนั้น ให้จับคู่บทความนี้กับ ดูสแต็กเอเจนต์ใหม่ของ OpenAI หากคุณต้องการมุมการปฏิบัติงาน โปรดอ่าน คู่มือการผลิตของเราสำหรับตัวแทน AI
เทมเพลตที่เป็นประโยชน์สำหรับผู้สร้าง
หากคุณกำลังออกแบบระบบตัวแทนของคุณเอง รูปแบบ Claw Code จะแนะนำเทมเพลตที่ใช้งานได้จริง:
- วางขอบเขตความน่าเชื่อถือในรันไทม์ที่แข็งแกร่งที่สุดที่คุณมี
- เก็บเครื่องมือ สิทธิ์ และเซสชันไว้ใกล้กับขอบเขตนั้น
- ใช้ชั้นที่สองเฉพาะเมื่อมีงานที่ชัดเจนเท่านั้น
- ทำให้การโยกย้ายและความเท่าเทียมกันทำงานอย่างชัดเจนแทนที่จะโบกมือ
- ทดสอบพื้นผิวที่ "น่าเบื่อ" อย่างจริงจังพอๆ กับพื้นผิวที่ฉูดฉาด
จุดสุดท้ายนั้นสำคัญ
ตัวแทนมักจะล้มเหลวในจุดที่น่าเบื่อก่อน:
- ดำเนินการต่อเซสชั่น
- การรวมการกำหนดค่า
- ค่าเริ่มต้นของการอนุญาต
- การกรองเครื่องมือ
- การทำให้เป็นอนุกรม
- ตะขอยิงผิดลำดับ
สิ่งเหล่านี้เป็นปัญหารันไทม์ ไม่ใช่ทำให้เกิดปัญหา
ใช้เวลาสุดท้าย
บทเรียนที่แท้จริงจาก Claw Code ไม่ใช่ "Rust ดีกว่า Python" หรือในทางกลับกัน
บทเรียนก็คือตอนนี้ตัวแทนการเขียนโค้ดทำงานจริงได้เพียงพอแล้ว โดยที่ทีมเริ่มจัดสรรภาษาตามความรับผิดชอบ
นั่นคือสัญญาณของวุฒิภาวะ
เมื่อระบบเปลี่ยนจากสภาพแวดล้อมสาธิตไปสู่สภาพแวดล้อมการปฏิบัติงาน กลยุทธ์การใช้งานจะเปลี่ยนไปตามนั้น
และนั่นคือสิ่งที่ repo นี้ทำให้มองเห็นได้
สำรวจซีรี่ส์เต็ม
สำหรับเส้นทางการอ่านแบบเต็ม โปรดไปที่ ฮับหัวข้อ AI Coding Agent Stack โดยนำซีรีส์นี้มารวมกับความครอบคลุมที่เกี่ยวข้องกับ MCP เครื่องมือสำหรับนักพัฒนา และการออกแบบตัวแทนที่คำนึงถึงการผลิต
อ่านต่อไป
- เครื่องมือ สิทธิ์ และ MCP: วิธีที่ตัวแทนการเข้ารหัสกลายเป็นจริง
- การเขียนซ้ำในห้องสะอาดและการตรวจสอบความเท่าเทียมกันสำหรับทีมตัวแทน AI
- คู่มือการผลิตตัวแทน AI