Cursor 2.0 และ Composer: วิธีที่ตัวแทนหลายตัวคิดใหม่เกี่ยวกับการเขียนโค้ด AI ที่น่าประหลาดใจ

Cursor ซึ่งเป็นแพลตฟอร์มตัวแทนและตัวแก้ไขโค้ดที่เน้น AI เป็นหลัก เปิดตัวแล้ว เคอร์เซอร์ 2.0 ในวันที่ 29 ตุลาคม 2025 — การอัปเดตครั้งใหญ่ที่จับคู่โมเดลการเข้ารหัสที่สร้างขึ้นเพื่อจุดประสงค์เฉพาะ (ชื่อ แต่ง) ด้วยอินเทอร์เฟซที่ออกแบบใหม่โดยเน้นที่เอเจนต์เป็นศูนย์กลาง พร้อมชุดอัปเกรดแพลตฟอร์มที่มุ่งเป้าไปที่การเขียนโค้ดแบบเอเจนต์ให้รวดเร็วขึ้น ปลอดภัยขึ้น และทำงานร่วมกันได้มากขึ้น บริษัทวางตำแหน่งการเปิดตัวครั้งนี้ว่าเป็นการเปลี่ยนแปลงเชิงกลยุทธ์จากการเชื่อมต่อกับโมเดลจากภายนอก ไปสู่การนำเสนอโมเดลและเครื่องมือที่ผ่านการฝึกอบรมของตนเอง ซึ่งได้รับการปรับแต่งให้เหมาะสมตั้งแต่ต้นจนจบสำหรับการพัฒนาซอฟต์แวร์แบบเอเจนต์

ด้านล่างนี้: เจาะลึกสิ่งที่ Cursor นำมาใน 2.0, Composer ถูกสร้างขึ้นมาอย่างไร, รายการบันทึกการเปลี่ยนแปลงที่ชัดเจน และ — ที่สำคัญที่สุด — สิ่งที่ทำให้โลกของ AI สำหรับนักพัฒนาประหลาดใจอย่างแท้จริง เกี่ยวกับการเปิดตัวนี้

Cursor คืออะไร (และเหตุใดนักพัฒนาจึงควรใส่ใจ)

Cursor เป็นตัวแก้ไขและแพลตฟอร์มที่ออกแบบตั้งแต่พื้นฐานเพื่อให้นักพัฒนาสามารถใช้ AI ได้ ตัวแทน ในฐานะผู้ร่วมมือระดับแนวหน้าในเวิร์กโฟลว์การเขียนโค้ด เวิร์กโฟลว์นี้ประกอบด้วยตัวแก้ไขแบบโลคัล/รีโมต การประสานงานเอเจนต์ การผสานรวมเครื่องมือ (เทอร์มินัล เบราว์เซอร์ การค้นหาเชิงความหมาย) และเวิร์กโฟลว์ที่เน้นโมเดล เพื่อให้เอเจนต์สามารถอ่าน วางแผน แก้ไข ทดสอบ และทำซ้ำบนฐานโค้ดจริงได้ บริษัทยกย่อง Cursor ว่าเป็น "วิธีที่ดีที่สุดในการเขียนโค้ดด้วย AI" โดยมุ่งเน้นที่การช่วยให้เอเจนต์สามารถทำงานด้านวิศวกรรมที่เป็นประโยชน์ได้ แทนที่จะเพียงแค่เติมบรรทัดอัตโนมัติ

เหตุใด Cursor 2.0 จึงมีความสำคัญในตอนนี้

ผู้ช่วย AI สำหรับโค้ดได้ก้าวข้ามการทำงานแบบเทิร์นเดียวไปสู่เวิร์กโฟลว์แบบหลายขั้นตอนที่ยาวขึ้น (วางแผน → แก้ไข → ทดสอบ → ทำซ้ำ) ซึ่งก่อให้เกิดปัญหาคอขวดใหม่ๆ เช่น ความหน่วง ความถูกต้องของบริบทในคลังข้อมูลขนาดใหญ่ การดำเนินการคำสั่งเชลล์/CI อย่างปลอดภัย และการทำงานของมนุษย์ในการตรวจสอบการเปลี่ยนแปลงของเอเจนต์ เคอร์เซอร์ 2.0 กำหนดเป้าหมายไปที่คอขวดเหล่านั้นโดยตรงโดยการจัดส่งทั้งโมเดลที่ปรับแต่งสำหรับเวิร์กโฟลว์ของตัวแทน และ UI/สถาปัตยกรรมพื้นฐานที่ช่วยให้สามารถรันเอเจนต์หลายตัวพร้อมกันได้อย่างปลอดภัย กล่าวโดยสรุปคือ Cursor กำลังพยายามเป็นฟูลสแต็กสำหรับวิศวกรรมซอฟต์แวร์ที่เน้นเอเจนต์เป็นหลัก

คุณสมบัติการอัปเดตเคอร์เซอร์ 2.0：

• เร็วขึ้น 4 เท่า—บทสนทนาโดยเฉลี่ยเสร็จสิ้นในเวลาไม่ถึง 30 วินาที
• ความสามารถในการทำงานหลายขั้นตอนที่ได้รับการปรับปรุง—สามารถจัดการโซ่โค้ดที่ซับซ้อนได้อย่างอิสระ
• การค้นหาเชิงความหมายที่ได้รับการปรับปรุง—สามารถเข้าใจและค้นหาความสัมพันธ์ทั่วทั้งฐานโค้ดได้
• การเพิ่มประสิทธิภาพการโต้ตอบแบบหน่วงเวลาต่ำ เหมาะสำหรับการพัฒนาแบบเรียลไทม์และการสร้างต้นแบบอย่างรวดเร็ว
• การฝึกอบรมการเรียนรู้เชิงเสริมแรง (RL) ได้รับการปรับให้เหมาะสมสำหรับการเข้ารหัสตามตัวแทน

แนวคิดหลักเบื้องหลัง Cursor 2.0 คืออะไร?

แกนหลักของ Cursor 2.0 คือการขับเคลื่อนแนวคิดที่เชื่อมโยงกันสามประการ:

1. การออกแบบตัวแก้ไขที่เน้นตัวแทนเป็นหลัก

แทนที่จะติดตั้งเอเจนต์ทับบน IDE แบบดั้งเดิม Cursor 2.0 จะเปิดเผยเอเจนต์เป็นออบเจ็กต์ในตัวแก้ไข ซึ่งมองเห็นได้ในแถบด้านข้าง จัดการได้ในรูปแบบกระบวนการ และสามารถรัน "แผน" (กลยุทธ์หลายขั้นตอน) กับที่เก็บได้ สิ่งนี้ทำให้การทำงานของ AI กลายเป็นงานที่ควบคุมได้ ซึ่งแต่ละงานจะมีอินพุต บันทึก และเอาต์พุตที่วิศวกรสามารถตรวจสอบได้

2. โมเดลการเขียนโค้ดที่รวดเร็วและออกแบบมาเพื่อวัตถุประสงค์เฉพาะ (Composer)

โมเดลใหม่ของ Cursor คือ Composer ซึ่งเป็นโมเดลการเขียนโค้ดแนวหน้าที่ได้รับการฝึกฝนและปรับแต่งมาโดยเฉพาะสำหรับการโต้ตอบแบบเอเจนต์ภายในสภาพแวดล้อม Cursor โดยโมเดลนี้เน้นที่ทรูพุตและการตอบสนอง ซึ่งเป็นคุณสมบัติสำคัญสำหรับการเขียนโค้ดแบบวนซ้ำสั้นๆ ภายในโปรแกรมแก้ไข มากกว่าเกณฑ์มาตรฐานแบบดิบๆ ที่มีความซับซ้อนสูง บริษัทรายงานว่า Composer ทำได้ประมาณ ความเร็วรุ่น 4× เมื่อเทียบกับโมเดลที่มีความสามารถใกล้เคียงกัน และสามารถทำงานแบบอินเทอร์แอคทีฟส่วนใหญ่ได้ภายในเวลาไม่ถึง 30 วินาทีในการทดสอบประสิทธิภาพภายใน ความเร็วนี้ไม่ได้เป็นเพียงความสะดวกสบายเท่านั้น แต่ยังเปลี่ยนความรู้สึกของเวิร์กโฟลว์แบบเอเจนต์ (จากการรอเป็นการทำงานซ้ำ) อีกด้วย

3. การดำเนินการตัวแทนแบบขนานและแยกกัน

Cursor 2.0 ช่วยให้ทีมสามารถรันเอเจนต์หลายตัวพร้อมกันในโปรเจ็กต์เดียวกัน พร้อมป้องกันไฟล์ขัดแย้งกันด้วยการแซนด์บ็อกซ์พื้นที่ทำงานของเอเจนต์แต่ละตัว (ผ่านเทคนิคต่างๆ เช่น git worktrees หรือ remote worker sandboxes) ซึ่งช่วยให้สามารถสำรวจ "จะเกิดอะไรขึ้นถ้า" ได้ในระดับขนาดใหญ่: รันกลยุทธ์การซ่อมแซมที่แตกต่างกันหลายแบบ รีแฟกเตอร์ตัวแปร หรือทดสอบไปป์ไลน์พร้อมกัน และเปรียบเทียบผลลัพธ์โดยไม่กระทบกัน

---

บันทึกการเปลี่ยนแปลงของ Cursor 2.0: มีอะไรใหม่บ้าง?

Cursor ได้เผยแพร่บันทึกการเปลี่ยนแปลงโดยละเอียดควบคู่ไปกับการประกาศเวอร์ชัน 2.0 ไฮไลต์ด้านล่างนี้สรุปการเปลี่ยนแปลงที่สำคัญที่สุดของผลิตภัณฑ์และงานวิจัย

Composer — โมเดลการเข้ารหัสแบบเอเจนต์ตัวแรกของเคอร์เซอร์

• แบบจำลองชายแดนที่สร้างขึ้นเพื่อจุดประสงค์: Composer ได้รับการอธิบายว่าเป็นโมเดล "frontier" ที่ปรับแต่งมาสำหรับงานวิศวกรรมซอฟต์แวร์และความเร็วของเอเจนต์ โมเดลนี้ได้รับการฝึกฝนโดยสามารถเข้าถึงเครื่องมือโค้ดเบสระหว่างการฝึกฝน ซึ่งช่วยให้มันเรียนรู้รูปแบบการค้นหา การแก้ไข และการแก้ปัญหาแบบหลายขั้นตอนภายในคลังข้อมูลจริง
• ข้อได้เปรียบด้านความเร็ว: เคอร์เซอร์รายงานว่า Composer เป็นประมาณ เร็วขึ้น 4 เท่า ในการผลิตผลงานมากกว่าโมเดลของปัญญาประดิษฐ์ที่เปรียบเทียบได้ในเกณฑ์มาตรฐาน และการสนทนาส่วนใหญ่เสร็จสิ้นในเวลาไม่ถึง 30 วินาทีในทางปฏิบัติ ซึ่งถือเป็นการปรับปรุงที่สำคัญสำหรับเซสชันแบบโต้ตอบ
• การเพิ่มประสิทธิภาพของตัวแทน: Composer ได้รับการฝึกอบรมในสภาวะแวดล้อมแบบเอเจนต์ (การเข้าถึงเครื่องมือต่างๆ เช่น การค้นหาเชิงความหมาย การแก้ไข และการทดสอบ) และปรับแต่งด้วยวิธีการเรียนรู้แบบเสริมแรง (reinforcement learning) เพื่อให้การเปลี่ยนแปลงโค้ดรวดเร็วและเชื่อถือได้ เนื้อหาบางส่วนที่เป็นอิสระชี้ให้เห็นถึงสถาปัตยกรรมแบบ MoE (การผสมผสานของผู้เชี่ยวชาญ) และการปรับแต่ง RL ในสูตรการฝึกของโมเดล

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

ตัวแทนหลายราย: การประสานงานตัวแทนแบบคู่ขนาน

การจัดการแถบด้านข้างและแผน: UI ตัวแก้ไขใหม่ช่วยให้นักพัฒนาสามารถสร้าง ตั้งชื่อ และจัดการตัวแทนและ "แผน" หลายรายการ (กลยุทธ์ตัวแทนหลายขั้นตอน) พร้อมแถบด้านข้างที่คงอยู่ เพื่อให้ตรวจสอบตัวแทนและบันทึกของพวกเขาได้ง่าย

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

เบราว์เซอร์ (GA): ตัวแทนอนุญาตให้ทดสอบและตรวจสอบ UI เว็บจริง

เบราว์เซอร์ได้รับการยกระดับเป็น GA:* เบราว์เซอร์ภายในเอเจนต์ของเคอร์เซอร์ ซึ่งเดิมเป็นเวอร์ชันเบต้า ปัจจุบันพร้อมใช้งานทั่วไปแล้วและผสานรวมเข้ากับตัวแก้ไขได้ดีขึ้น เอเจนต์สามารถโต้ตอบกับเว็บเพจ ดึงองค์ประกอบ DOM และส่งต่อข้อมูลที่มีโครงสร้างกลับไปยังรันไทม์ของเอเจนต์ได้ ซึ่งช่วยให้เอเจนต์สามารถค้นคว้าเอกสาร ดึงข้อมูล API จากระยะไกล และแก้ไขจุดบกพร่องผ่านเว็บได้โดยไม่ต้องออกจากตัวแก้ไข

ผลกระทบต่อนักพัฒนา: ขณะนี้ตัวแทนสามารถตรวจสอบการเปลี่ยนแปลง UI สร้างจุดบกพร่องของไคลเอนต์ซ้ำ และทำซ้ำด้วยหลักฐาน DOM/ภาพที่เป็นรูปธรรม แทนที่จะเป็นคำอธิบายข้อความที่มองไม่เห็น

ปรับปรุงการตรวจสอบโค้ดและความแตกต่าง

การตรวจสอบการเปลี่ยนแปลงตัวแทนจากหลายไฟล์ได้ง่ายขึ้น Cursor 2.0 ปรับปรุงกระบวนการตรวจสอบสิ่งที่ตัวแทนเปลี่ยนแปลงในที่เก็บข้อมูลโดยไม่ต้องสลับไปมาระหว่างไฟล์ ความแตกต่างจะถูกนำเสนอในลักษณะที่ลดภาระงานทางปัญญา

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

เทอร์มินัลแซนด์บ็อกซ์ (GA) และการควบคุมความปลอดภัย

เทอร์มินัลแซนด์บ็อกซ์คือ GA (macOS) และรันคำสั่งเชลล์ตัวแทนในสภาพแวดล้อมที่ปลอดภัยตามค่าเริ่มต้น การรันเชลล์จะถูกแซนด์บ็อกซ์พร้อมสิทธิ์การอ่าน/เขียนในพื้นที่ทำงาน ไม่มีเครือข่ายตามค่าเริ่มต้น และอยู่ในรายการที่อนุญาตสำหรับคำสั่งที่ละเอียดอ่อน มีระบบควบคุมผู้ดูแลระบบสำหรับองค์กร
ผลกระทบต่อนักพัฒนา: การดำเนินการตัวแทนที่ปลอดภัยนั้นมีความสำคัญอย่างยิ่ง การทำแซนด์บ็อกซ์จะช่วยลดความเสี่ยงเมื่อตัวแทนจำเป็นต้องรันการทดสอบ รันลินเตอร์ หรือรันคำสั่งชั่วคราว

โหมดเสียง โหมดแผน และตัวแทนพื้นหลัง

• การควบคุมด้วยเสียง สำหรับตัวแทน (การแปลงคำพูดเป็นข้อความ + คำสำคัญการส่งแบบกำหนดเอง)
• โหมดแผน: สร้างแผนโดยใช้แบบจำลองหนึ่งและดำเนินการด้วยแบบจำลองอื่น แผนสามารถรันในเบื้องหน้าหรือเบื้องหลังได้
• พื้นหลังและตัวแทนคลาวด์:การเริ่มต้นที่รวดเร็วยิ่งขึ้น ความน่าเชื่อถือ 99.9% สำหรับตัวแทนบนคลาวด์ การมองเห็นงานเบื้องหลังที่ดีขึ้น

Cursor 2.0 ส่งสัญญาณอะไรให้กับภูมิทัศน์การเขียนโค้ด AI ที่กว้างขึ้น?

การเคลื่อนไหวของเคอร์เซอร์มีความโดดเด่นด้วยเหตุผลสองประการ:

1. ความเชี่ยวชาญเหนือความทั่วไป Composer เป็นตัวอย่างแนวโน้มในการสร้างโมเดลที่ปรับแต่งให้เหมาะกับโดเมนและรันไทม์เฉพาะ (ในที่นี้: การเขียนโค้ดแบบเอเจนต์ภายใน IDE) แทนที่จะใช้โมเดลทั่วไปเพียงตัวเดียวเพื่อรองรับทุกกรณีการใช้งาน ทีมต่างๆ กำลังถกเถียงกันถึงโมเดลที่ออกแบบร่วมกับ UX และทูลเชนที่พวกเขาใช้
2. การประสานงานตัวแทนเป็นผลิตภัณฑ์ดั้งเดิม UI ของเคอร์เซอร์จะจัดการเอเจนต์เสมือนเป็นทรัพยากรที่มีการจัดการ ซึ่งคุณสามารถควบคุม ตรวจสอบ และกำหนดเวอร์ชันได้ รูปแบบผลิตภัณฑ์ดังกล่าว — เอเจนต์เป็นกระบวนการที่มีการจัดการพร้อมเวิร์กทรีที่แยกจากกันและแผนการที่ใช้ร่วมกัน — น่าจะปรากฏในเครื่องมือสำหรับนักพัฒนาอื่นๆ ขณะที่ทีมต่างๆ มุ่งขยายขนาดความช่วยเหลือแบบอัตโนมัติอย่างปลอดภัย

การผสมผสานนี้ — โมเดลเฉพาะทางที่รวดเร็วกว่าบวกกับ UX การประสานงานที่จงใจ — ทำให้ภาคอุตสาหกรรมเคลื่อนตัวออกจาก "โมเดลที่เป็นการเติมข้อความอัตโนมัติ" ไปเป็น "โมเดลที่เป็นผู้ทำงานร่วมกันอย่างแข็งขัน" มากขึ้น แต่ยังก่อให้เกิดคำถามเกี่ยวกับการกำกับดูแลที่ทุกทีมจะต้องตอบอีกด้วย

ฉันจะเข้าถึง Cursor 2.0 ได้อย่างไร?

1. ดาวน์โหลดหรืออัปเดตแอป Cursor จากเว็บไซต์อย่างเป็นทางการ (Cursor เผยแพร่เวอร์ชันต่างๆ จากเว็บไซต์) Cursor 2.0 เปิดตัวในฐานะผลิตภัณฑ์ v2 (Composer + UI แบบหลายเอเจนต์) ดังนั้นการอัปเดตเป็น Cursor เวอร์ชันล่าสุดจึงเป็นขั้นตอนแรก

2. ตรวจสอบให้แน่ใจว่าคุณได้เปิดใช้งาน Cursor 2.0 / Composer แล้ว

• ราคาของ Cursor ขึ้นอยู่กับแผนการสมัครสมาชิก ซึ่งแต่ละแผนมีระดับการเข้าถึง Composer และโมเดลอื่นๆ ที่แตกต่างกัน บริษัทมีแพ็กเกจ Hobby ให้ใช้งานฟรี แต่ผู้ใช้มืออาชีพมักจะเลือกแพ็กเกจแบบชำระเงินเพื่อปลดล็อกฟีเจอร์ทั้งหมด
• เคอร์เซอร์เวอร์ชัน 2.0 (Composer, UI แบบหลายเอเจนต์, เบราว์เซอร์ในแอป ฯลฯ) ได้รับการเน้นไว้ในบันทึกการเปลี่ยนแปลง หากแอปอัปเดตอัตโนมัติ คุณควรใช้เวอร์ชัน 2.0 อยู่แล้ว หากไม่เป็นเช่นนั้น ให้อัปเดตแอปจากหน้าดาวน์โหลดหรือจากกล่องโต้ตอบอัปเดตของแอป
• ฟีเจอร์ Composer หรือฟีเจอร์หลายไฟล์/เอเจนต์อาจอยู่เบื้องหลังการสลับเบต้าในการตั้งค่า (เวอร์ชันเก่ากว่า) หากคุณไม่เห็น Composer ให้ตรวจสอบ การตั้งค่า → ฟีเจอร์/เบต้า และเปิดใช้งาน โดยปกติ Composer จะเปิดผ่านทางลัด Composer/เอเจนต์ (เช่น Ctrl/Cmd + I) หรือจากบานหน้าต่างด้านข้าง Composer สามารถเปิด/ปิดได้ และจะปรากฏใน Agent/Composer UI

3. กำหนดค่าคีย์/โมเดล API:เคอร์เซอร์ใช้คีย์ API ที่กำหนดค่าไว้เพื่อเรียกผู้ให้บริการ LLM (OpenAI, Anthropic, Google หรือผู้ให้บริการแบบกำหนดเอง เช่น โคเมทเอพีไอ) เปิดเคอร์เซอร์ → การตั้งค่า → โมเดล (หรือ การตั้งค่า → คีย์ API) เพื่อเพิ่มคีย์ผู้ให้บริการและ URL ฐานแบบกำหนดเอง เคอร์เซอร์จะให้คุณเลือกโมเดลที่เปิดใช้งานภายใน Chat / Agent / Composer

ฉันจะใช้ CometAPI ภายใน Cursor ได้อย่างไร (ทีละขั้นตอน)

สรุปสั้นๆ: CometAPI คือเกตเวย์รวมโมเดล (ปลายทางเดียวที่สามารถพร็อกซีผู้จำหน่ายโมเดลหลายราย) ในการใช้งานใน Cursor คุณต้องลงทะเบียนที่ CometAPI รับคีย์ API และตัวระบุโมเดล จากนั้นเพิ่มคีย์และปลายทางนั้นลงในการตั้งค่าโมเดลของ Cursor เป็นผู้ให้บริการแบบกำหนดเอง (แทนที่ URL ฐาน) และเลือกโมเดล CometAPI ในโหมด Composer/Agent

ขั้นตอนที่ A — รับข้อมูลประจำตัว CometAPI ของคุณ

1. ลงทะเบียนที่ CometAPI และ สร้างรหัส API จากแดชบอร์ดของพวกเขา เก็บกุญแจไว้เป็นความลับ (ปฏิบัติเช่นเดียวกับโทเค็นผู้ถือทั่วไป)
2. สร้าง / คัดลอกรหัส API และจดบันทึกชื่อรุ่น / ID ที่คุณต้องการใช้ (เช่น claude-sonnet-4.5 หรือโมเดลผู้จำหน่ายอื่นที่มีให้ผ่าน CometAPI) เอกสาร/คู่มือ CometAPI อธิบายกระบวนการและรายชื่อชื่อรุ่นที่รองรับ

ขั้นตอนที่ B — เพิ่ม CometAPI เป็นโมเดล/ผู้ให้บริการแบบกำหนดเองใน Cursor

1. เปิดเคอร์เซอร์ → การตั้งค่า → Models (หรือการตั้งค่า → คีย์ API)
2. หากเคอร์เซอร์แสดง “เพิ่มโมเดลที่กำหนดเอง” or “แทนที่ URL ฐาน OpenAI” ตัวเลือกใช้:

• URL ฐาน / จุดสิ้นสุด: วาง URL ฐานที่เข้ากันได้กับ OpenAI ของ CometAPI (CometAPI จะบันทึกว่าเปิดเผยหรือไม่ openai/v1 จุดสิ้นสุดสไตล์หรือจุดสิ้นสุดเฉพาะผู้ให้บริการ) (ตัวอย่าง: https://api.cometapi.com/v1 — ใช้ URL จริงจากเอกสาร CometAPI)
• คีย์ API: วางรหัส CometAPI ของคุณลงในช่องรหัส API
• ชื่อรุ่น: เพิ่มตัวระบุโมเดลให้ตรงตามเอกสาร CometAPI (เช่น claude-sonnet-4.5 or composer-like-model).

3. ตรวจสอบ การเชื่อมต่อหากเคอร์เซอร์มีปุ่ม "ยืนยัน" / "ทดสอบ" กลไกโมเดลแบบกำหนดเองของเคอร์เซอร์มักกำหนดให้ผู้ให้บริการต้องเข้ากันได้กับ OpenAI (หรือเคอร์เซอร์ต้องยอมรับ URL พื้นฐาน + คีย์) คู่มือชุมชนแสดงรูปแบบเดียวกัน (แทนที่ URL พื้นฐาน → ระบุคีย์ → ตรวจสอบ)

ขั้นตอน C — เลือกโมเดล CometAPI ภายใน Composer / Agent

1. เปิด Composer หรือ Agent (ทางลัด Ctrl/Cmd + I หรือบานข้าง)
2. สลับการเลือกโมเดลจากอัตโนมัติ (หรือโมเดลปัจจุบันของคุณ) ไปเป็นผู้ให้บริการ / โมเดลแบบกำหนดเองที่คุณเพิ่งเพิ่ม
3. เริ่มเซสชัน Composer หรือสร้างเอเจนต์และยืนยันว่าตอบสนองโดยใช้โมเดล CometAPI ที่คุณเลือก ทดสอบด้วยพรอมต์เล็กๆ (เช่น "ค้นหาที่เก็บและเพิ่มการทดสอบยูนิตสำหรับฟังก์ชันที่ล้มเหลวใน tests/”) เพื่อตรวจสอบพฤติกรรม

สรุป: นี่เป็นการอัปเดตที่สำคัญหรือไม่?

Cursor 2.0 ไม่ใช่แค่การอัปเดตฟีเจอร์เท่านั้น แต่ยังเป็นแนวคิดระดับผลิตภัณฑ์ที่ผสานรวมโมเดลการเขียนโค้ดที่สร้างขึ้นโดยเฉพาะเข้ากับโครงสร้างดั้งเดิมของการประสานงาน (orchestration) ที่ทำให้เวิร์กโฟลว์แบบเอเจนต์ใช้งานได้จริง องค์ประกอบที่น่าประหลาดใจ ได้แก่ โมเดลเอเจนต์ภายในองค์กร (Composer) ที่ได้รับการปรับแต่งให้เหมาะสมสำหรับความเร็วโดยเฉพาะ รันไทม์แบบหลายเอเจนต์พร้อมกลไกการแยกตัวที่เป็นรูปธรรม และการผสานรวมเครื่องมือที่ลึกซึ้งยิ่งขึ้น เช่น เบราว์เซอร์ GA ล้วนเป็นสัญญาณบ่งบอกถึงพัฒนาการของ AI ในการผสานรวมกับวิศวกรรมซอฟต์แวร์ สำหรับทีมที่ให้ความสำคัญกับการตรวจสอบ การทดสอบ และการรักษาความสะอาดของเวิร์กโฟลว์ Cursor 2.0 นำเสนอเส้นทางที่น่าเชื่อถือสู่การวนซ้ำที่รวดเร็วขึ้นอย่างมีนัยสำคัญ และการทำงานด้านวิศวกรรมประจำวันให้เป็นระบบอัตโนมัติมากขึ้น สำหรับระบบนิเวศของนักพัฒนา AI ที่กว้างขึ้น การที่ Cursor มุ่งเน้นไปที่การประสานงานและเครื่องมือของเอเจนต์น่าจะผลักดันให้ผู้จำหน่ายรายอื่นคิดนอกกรอบการโต้ตอบแบบผู้ช่วยเพียงคนเดียว และมุ่งไปที่ทีมเอเจนต์ การป้องกันการปฏิบัติงาน และโมเดลที่คำนึงถึงความหน่วงแฝง