ปลดล็อกศักยภาพ AI Agents ของคุณด้วยการเข้าถึงผ่าน SSH

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

Oberik มอบ การเข้าถึง ssh ให้กับเอเจนต์ของคุณแทน

ไม่ใช่ให้คุณนะ คุณกำลังทำหน้าที่เป็นตัวแทนในบริบทนี้ มันให้การเข้าถึง SSH แก่ เอเจนต์ ของคุณจริงๆ

1 ssh ssh.oberik.com

SSH คือพื้นผิวที่เอเจนต์การเขียนโค้ดใช้เมื่อใดก็ตามที่ต้องโต้ตอบกับ Oberik (เช่น สร้างเวิร์กสเปซ, กำหนดขีดจำกัดความสามารถ, สร้างโทเค็น, แชทกับเอเจนต์ที่เราโฮสต์ ฯลฯ) ไม่มีไฟล์คอนฟิก, ไม่มีโทเค็นในตัวแปร env, ไม่มีอะไรต้องติดตั้ง เครื่องของคุณมีไคลเอนต์อยู่แล้ว และมันรู้วิธีจัดการข้อมูลประจำตัวชิ้นเดียวที่เกี่ยวข้องอยู่แล้ว

ทำไมไม่ใช่ MCP?

พูดสั้นๆ ก็คือ ปัญหาเรื่องผลลัพธ์ (output)

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

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

MCP รองรับการกรองและการแบ่งหน้าในหลักการ แต่ในทางปฏิบัติแล้ว มีคนต้องสร้างสิ่งนั้นลงในทุกเครื่องมือ และเมื่อมันหายไป ซึ่งเกิดขึ้นได้บ่อยครั้งต้องขอบคุณ vibe coding โมเดลก็แค่ กลืน ข้อมูลดิบนั้นและจ่ายค่าตอบแทนเป็นโทเค็นและความสนใจ (attention)

ด้วย SSH เอเจนต์จะประกอบมุมมองของตัวเองแทนที่จะยอมรับมุมมองที่เครื่องมือส่งให้

1$ ssh ssh.oberik.com 'documents --json' | jq -r '.data[].name'
2$ ssh ssh.oberik.com 'audit --limit 20 --json' | jq -r '.data[] | "\(.at) \(.command)"'

ตัวกรองทำงานในไปป์บนเครื่องนั้น ทันที ฟรี และแคบเท่าที่เอเจนต์ต้องการ โมเดลอ่านหนึ่งบรรทัดแทนที่จะเป็นสิบหน้า

มีสองสิ่งที่ทำให้สิ่งนี้ทำงานได้ ประการแรก ทุกการตอบสนองใช้รูปแบบบรรทัดเดียว เช่น {"ok":…, "command":…, "message":…, "data":…} ซึ่งทำให้ jq เป็นวิธีที่ intended ในการอ่านผลลัพธ์ ไม่ใช่แค่วิธีแก้ไขปัญหา

โหมด JSON ยังช่วยให้การโต้ตอบไม่รบกวนสตรีมของคุณ หากคำสั่งขาดฟิลด์ที่จำเป็น มันจะบอกคุณว่าขาดอะไรไปแทนที่จะเปิดฟอร์ม หากคำสั่งอาจเป็นอันตราย มันจะบอกให้คุณรันใหม่ด้วย --yes แทนที่จะหยุดเพื่อขอการยืนยัน

สำหรับบรรทัดที่มีหลายคำสั่ง ให้ใส่ format json; ไว้ที่ตอนเริ่มต้น ซึ่งจะตั้งค่ารูปแบบเพียงครั้งเดียว คุณจึงไม่ต้องทำซ้ำแฟล็ก

มีรายละเอียดหนึ่งที่ควรรู้ แฟล็กต้องอยู่ภายในเครื่องหมายคำพูด ssh ssh.oberik.com --json 'documents' ใช้ไม่ได้เพราะ ssh ถือว่าอ็อพชันหลังจากปลายทางเป็นของตัวเอง มันจะละเว้นแฟล็ก และไคลเอนต์จะตอบสนองด้วยผลลัพธ์การใช้งานของตัวเอง เนื่องจากผลลัพธ์นั้นไม่ได้กล่าวถึง Oberik หรือแฟล็ก มันอาจทำให้โฮสต์ดูเสียได้

สิ่งที่เราพยายามจะบอกคือ เราได้ฝึกโมเดลเหล่านี้ให้ใช้ คอมพิวเตอร์ แล้ว ปล่อยให้พวกมันใช้ คอมพิวเตอร์ เถอะ

ทำไมไม่ใช้ API?

พูดสั้นๆ ก็คือ ปัญหาเรื่องข้อมูลประจำตัว (credential)

อย่าเข้าใจเราผิดนะ เรามี API ใน Oberik และมันก็ดี สิ่งที่ผลิตภัณฑ์ของคุณเรียกใช้ในโพรดักชัน และนี่คือสิ่งที่เกตเวย์ SSH เรียกใช้ภายใต้ฝาครอบ

แต่ถ้าคุณดูว่ามันต้องการอะไรจากผู้เรียก:

1. รับโทเค็น
2. จัดเก็บมัน
3. รีเฟรชมัน
4. เก็บมันให้พ้นจากล็อกและพ้นจากบริบทของโมเดล

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

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

ทำไมไม่ใช้ CLI?

พูดสั้นๆ ก็คือ ปัญหาเรื่องความล้าสมัย (staleness)

การติดตั้ง CLI เป็นข้อผูกมัดที่ต้องขอจากระบบรวบรวม (harness) ของผู้ผสานรวมทุกราย และเราไม่อยาก กล้า ขนาดนั้นเพราะเราเพิ่งเริ่มก้าวแรก พูดตามตรง เราไม่ต้องการ CLI เลย เพราะมันเป็นสำเนาที่หยุดนิ่งของผลิตภัณฑ์ แผนควบคุม (control plane) ของ Oberik จะเพิ่มฟีเจอร์เมื่อเราได้รับข้อเสนอแนะมากขึ้น ซึ่งหมายความว่าถ้าเราเลือกใช้ CLI เราจะต้องผลักดันเวอร์ชันใหม่ออกมาอย่างต่อเนื่อง และขอให้ผู้ใช้อัปเดต

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

ไม่มีอะไรต้องอัปเดต เพราะไม่มีอะไรถูกติดตั้ง

ทำไมไม่ใช้สกิล?

พูดสั้นๆ ก็คือ ปัญหาเรื่องคำแนะนำ (instructions)

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

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

คำตอบของเราสำหรับ "เอเจนต์รู้ได้อย่างไรว่า Oberik ทำอะไรได้บ้าง" ไม่ใช่ไฟล์ที่มันติดตั้ง มันคือการเรียกเพื่อค้นหา (discover) สำหรับเอเจนต์:

1$ ssh ssh.oberik.com 'discover'                  # ทุกคำสั่ง พารามิเตอร์และประเภทของมัน
2$ ssh ssh.oberik.com 'docs'                      # ทุกหน้า พร้อมกับสิ่งที่ครอบคลุม
3$ ssh ssh.oberik.com 'docs search capability'    # บรรทัดที่กล่าวถึงบางสิ่ง

พื้นผิวอธิบายตัวเอง ณ เวลาที่เชื่อมต่อ จากผลิตภัณฑ์จริง และ docs ก็เป็นข้อความเดียวกับเว็บไซต์ docs ดังนั้นจึงไม่มีอะไรที่เป็นบทสรุปของสิ่งอื่น คำแนะนำไม่มีวันล้าสมัย เพราะ พวกมันคือตัวผลิตภัณฑ์

ทำไมต้อง SSH?

พูดสั้นๆ ก็คือ มันแก้ปัญหาทั้งห้าข้อได้ในคราวเดียว

1. คีย์คือข้อมูลประจำตัวที่เอเจนต์สามารถถือได้จริง การรับรองความถูกต้องด้วยคีย์ SSH มีมานานหลายทศวรรษ ผ่านการพิสูจน์มาแล้วหลายพันล้านครั้ง และโปรโตคอลจะตรวจสอบลายเซ็นก่อนที่เราจะดูลายนิ้วมือด้วยซ้ำ เราไม่รู้สึกว่าต้อง reinvent the wheel ที่นี่ เราแค่หยุดขอให้โมเดลดูแลความลับ และปล่อยให้เครื่องทำงานเดียวที่มันถูกสร้างมาเพื่อทำเสมอ
2. คุณยังคงอยู่ในวงจรโดยไม่ต้องแชร์รหัสผ่าน เมื่อเอเจนต์ยังไม่มีคีย์ เช่น ระหว่างการเชื่อมต่อครั้งแรกกับ Oberik มันจะเริ่มโฟลว์การเข้าสู่ระบบแบบอุปกรณ์ (device login flow) เอเจนต์รัน login link ซึ่งจะส่งคืน URL และโค้ดทันที และแสดงทั้งสองอย่างให้คุณเห็น คุณเปิด URL ในเบราว์เซอร์ของคุณเอง หน้านี้จะระบุลายนิ้วมือคีย์ที่แน่นอนที่จะถูกแนบ ให้ตัวเลือกแก่คุณในการอนุมัติหรือปฏิเสธ และแสดงโค้ดที่คุณสามารถเปรียบเทียบกับโค้ดที่เอเจนต์พิมพ์ออกมา ในขณะเดียวกัน เอเจนต์จะรัน login wait และรอการตัดสินใจของคุณ คำสั่งเหล่านี้แยกจากกันโดยการออกแบบ หากคำสั่งเดียวสร้างลิงก์และรอ เอเจนต์จะแสดงลิงก์ให้คุณเห็นหลังจากที่คำขอหมดอายุแล้วเท่านั้น เมื่อคุณอนุมัติ คีย์จะถูกลงทะเบียน และการเชื่อมต่อในอนาคตทั้งหมดจะลงชื่อเข้าใช้โดยอัตโนมัติ คุณจะไม่ต้องใช้ลิงก์อื่นอีก ไม่มีความลับใดถูกเขียนลงในประวัติแชทของเอเจนต์เพราะกระบวนการนี้ไม่ได้ใช้ความลับ
3. ผลลัพธ์ถูกออกแบบมาสำหรับไปป์ ขอ JSON ด้วย --json บนคำสั่ง หรือใช้ format json; เพียงครั้งเดียวที่ตอนเริ่มต้นของบรรทัด และทุกการตอบสนองจะกลับมาเป็นซองจดหมาย (envelope) บรรทัดเดียว ซึ่งทำให้ jq '.data[0].name' เป็นวิธีที่ intended ในการอ่านผลลัพธ์ ไม่ใช่แค่วิธีแก้ไขปัญหา ตัวกรองทำงานบนเครื่อง ดังนั้นโมเดลจะเห็นเฉพาะสิ่งที่เหลืออยู่หลังจากการกรอง ข้อผิดพลาดใช้ซองจดหมายเดียวกันและรวมถึงสถานะ HTTP พื้นฐาน ซึ่งช่วยให้การลองใหม่แยกแยะ 429 จาก 400 ได้ ไปป์ทำงานในทั้งสองทิศทางเช่นกัน เกตเวย์ไม่สามารถอ่านดิสก์ของคุณ ดังนั้นคำสั่งที่รับไฟล์จะใช้ชื่อไฟล์เป็นอาร์กิวเมนต์และอ่านเนื้อหาของไฟล์จากการเชื่อมต่อ ตัวอย่างเช่น ssh ssh.oberik.com 'document upload handbook.pdf' < handbook.pdf อัปโหลดไฟล์
4. ไม่ต้องติดตั้งอะไรเลย ไม่มีอะไรต้องลงทะเบียน ไม่มีอะไรต้องจัดเก็บ ไม่มีอะไรต้องเก็บไว้ในบริบท ไม่มีเซิร์ฟเวอร์ MCP ในคอนฟิกของเอเจนต์ของคุณ ไม่มีโทเค็นในตัวแปร env ไม่มี CLI ใน PATH ไม่มีไฟล์สกิล เราสร้างผลิตภัณฑ์สำหรับนักพัฒนา ดังนั้นเราจึงใช้เครื่องมือที่มีอยู่แล้ว และเอเจนต์ทุกตัวรู้วิธีใช้: SSH
5. อธิบายตัวเองและออกแบบมาอย่างระมัดระวัง discover จะพิมพ์แคตตาล็อกคำสั่งทั้งหมด ซึ่งรวมถึงทุกคำสั่ง พารามิเตอร์และประเภทของมัน และข้อกำหนดการยืนยันใดๆ แคตตาล็อกถูกสร้างขึ้นแบบเรียลไทม์จากผลิตภัณฑ์ มันยังบอกไคลเอนต์ว่าฟิลด์ใดคาดหวังไบต์ไฟล์แทนที่จะเป็นสตริง ดังนั้นการอัปโหลดจึงไม่สามารถเดาผิดได้ สิ่งที่ไม่อนุญาตคือการกำหนดเป้าหมายแถวด้วยหมายเลขของมัน คำสั่งที่ทำลายล้างต้องใช้ชื่อ และเซิร์ฟเวอร์จะตรวจสอบชื่อนั้นกับโปรเจกต์ที่เลือกโดยการเชื่อมต่อ หากมีการร้องขอ Staging ในขณะที่เลือก Support Bot อยู่ เซิร์ฟเวอร์จะส่งคืน 400 และปล่อยเวิร์กสเปซไว้โดยไม่ถูกแตะต้อง

ไม่มีอะไรต้องสอน เพราะพื้นผิวสอนตัวเอง

นี่คือลักษณะของโฟลว์การเข้าสู่ระบบของ Oberik:

โฟลว์การเข้าสู่ระบบของ Oberik

ประตู SSH เข้าสู่ผลิตภัณฑ์ของคุณไม่ใช่ความเสี่ยงเหรอ?

นั่นเป็นคำถามที่ยุติธรรม แต่ความจริงแล้วเกือบจะตรงกันข้าม

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

เทอร์มินัลนี้เปิดเผยต่ออินเทอร์เน็ตสาธารณะ ดังนั้นใครก็ตามสามารถเชื่อมต่อโดยไม่ระบุชื่อได้ ทุกคำสั่งจะถูกบันทึก รวมถึงข้อมูลประจำตัวการเชื่อมต่อ ที่อยู่ IP คีย์ และผลลัพธ์ ข้อมูลประจำตัวจะไม่ถูกจัดเก็บ รหัสผ่านที่ป้อนด้วย login หรือคีย์ผู้ให้บริการที่ส่งผ่าน --values จะถูกแทนที่ด้วย <redacted> ก่อนที่จะเขียนบันทึก ระบบยังจัดเก็บแฮชของคำสั่งดั้งเดิมเพื่อให้สามารถเชื่อมโยงคำสั่งที่ทำซ้ำได้โดยไม่ทำให้ข้อมูลประจำตัวสามารถกู้คืนได้ บันทึกจะถูกเก็บไว้เป็นเวลา 30 วันหรือ 100,000 คำสั่ง แล้วแต่ว่าอย่างไหนจะถึงก่อน

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

สรุปสั้นๆ

คนอื่นๆ มอบ API, เซิร์ฟเวอร์ MCP หรือไฟล์สกิลให้กับเอเจนต์ของคุณ เรามอบเทอร์มินัลให้มัน ปรากฎว่านั่นคือสิ่งที่มันต้องการ