สรุปสั้น: การกำกับดูแล AI agent คือชุดกฎที่กำหนดว่าใครสามารถเริ่ม agent ได้ agent เข้าถึงอะไรได้บ้าง เชื่อมต่อไปถึงอะไรได้บ้าง ใครเป็นผู้อนุมัติเมื่อ agent ขอสิทธิ์เพิ่ม และมีบันทึกอะไรหลงเหลืออยู่ แซนด์บ็อกซ์ Codex ของ OpenAI และ AI Governance ของ Docker ต่างบังคับใช้ครึ่งหนึ่งของรายการดังกล่าวในระดับรันไทม์ ส่วนอีกครึ่งหนึ่ง คือความเป็นเจ้าของและการรีวิว ขึ้นอยู่กับวิธีที่ทีมของคุณมอบหมายและรับงานจาก agent
การกำกับดูแล AI agent คืออะไร?
การกำกับดูแล AI agent คือการกำหนดนโยบายและการเก็บบันทึกที่เกี่ยวข้องกับ agent อัตโนมัติ ได้แก่ ใครบ้างที่สามารถเปิดตัว agent ได้ agent ใช้ไฟล์และปลายทางเครือข่ายใดได้บ้าง เรียกใช้เครื่องมือใดได้บ้าง เมื่อใดที่มนุษย์ต้องอนุมัติการกระทำ และทุกการตัดสินใจถูกบันทึกไว้อย่างไร แนวคิดนี้มอง agent เป็นผู้กระทำที่มีอำนาจ ไม่ใช่เพียงโปรเซสที่ต้องกักเก็บ
กรอบความคิดนี้กลายเป็นพาดหัวข่าวของอุตสาหกรรมในสัปดาห์นี้ เมื่อวันที่ 19 พฤศจิกายน Docker ได้เปิดตัวแบรนด์ใหม่โดยอ้างอิงประโยคหนึ่งจาก Terri Avnaim ประธานเจ้าหน้าที่ฝ่ายการตลาด (CMO): "คอนเทนเนอร์แยกเวิร์กโหลดออกจากกัน แต่ agent ไม่ใช่เวิร์กโหลด agent คือผู้กระทำ" โพสต์ดังกล่าวยังระบุต่อว่า "agent ตัดสินใจเองว่าจะรันอะไร เข้าถึงอะไร และเปลี่ยนแปลงอะไร"
หนึ่งวันก่อนหน้านั้น OpenAI ได้เผยแพร่ Inside the Codex sandbox ซึ่งเป็นคำอธิบายอย่างละเอียดว่า Codex จำกัดสิ่งที่คำสั่งต่าง ๆ ทำได้บนแล็ปท็อปของคุณอย่างไร ผู้จำหน่ายสองราย การออกแบบสองแบบ แต่มีคำถามร่วมกันหนึ่งข้อ หากทีมของคุณรัน coding agent ผ่าน Sharkly อยู่แล้ว คู่มือนี้จะแสดงให้เห็นว่าการควบคุมในระดับรันไทม์สิ้นสุดตรงไหน และการกำกับดูแลระดับทีมต้องเข้ามารับช่วงต่อตรงไหน
ทำไมคำว่า "agent คือผู้กระทำ" จึงเปลี่ยนคำถาม
คอนเทนเนอร์ตอบคำถามเพียงข้อเดียว: โปรเซสนี้มองเห็นอะไรได้บ้าง? คำถามนั้นยังคงสำคัญ แต่ไม่ครอบคลุมทุกสิ่งที่ agent ทำ
agent อ่านงาน เลือกคำสั่ง เลือกไฟล์ที่จะแก้ไข ตัดสินใจว่าจะเรียกใช้เครื่องมือหรือไม่ และบางครั้งก็ขอสิทธิ์เพิ่มระหว่างทาง แต่ละอย่างล้วนเป็นการตัดสินใจ โพสต์ AI Governance ของ Docker สรุปช่องว่างนี้ได้ดีว่า "การตัดสินใจของโมเดลไม่ใช่การกระทำที่ได้รับอนุญาตโดยอัตโนมัติ"
ดังนั้นการกำกับดูแลจึงเปลี่ยนจาก "แยกโปรเซสออกจากกัน" เป็น "ให้อำนาจแก่ผู้กระทำ" คุณต้องมีคำตอบสำหรับคำถามห้าข้อ:
- ใครเริ่มได้? ใครบ้างที่สามารถมอบหมายหรือเรียกใช้ agent ที่กำหนดได้
- เข้าถึงอะไรได้? พาธในระบบไฟล์ อ่านหรือเขียน
- เชื่อมต่อไปถึงอะไรได้? โดเมนเครือข่ายและเครื่องมือ MCP (Model Context Protocol)
- ใครอนุมัติการยกระดับสิทธิ์? เกิดอะไรขึ้นเมื่อ agent ขอมากกว่าค่าเริ่มต้น
- มีบันทึกอะไรไว้? ใครรันอะไร อะไรได้รับอนุญาตหรือถูกปฏิเสธ และใครรับรองผลลัพธ์
แนวทางสองแบบในปัจจุบันจัดการคำถามข้อ 2 ถึง 4 ด้วยวิธีที่ต่างกัน ส่วนคำถามข้อ 1 และคำถามข้อ 5 เป็นส่วนใหญ่อยู่นอกเหนือทั้งสองแนวทาง

แซนด์บ็อกซ์ Codex กำกับการเข้าถึงของ agent อย่างไร
แซนด์บ็อกซ์ Codex จำกัดคำสั่งภายในสภาพแวดล้อมที่คุณมีอยู่แล้ว แทนที่จะย้ายคำสั่งเหล่านั้นไปยัง VM หรือคอนเทนเนอร์ เหตุผลของ OpenAI นั้นใช้ได้จริงในทางปฏิบัติ: การ build สำหรับ iOS ต้องใช้เครื่องมือ native ของ Mac และตัวจำลอง ซึ่งคอนเทนเนอร์ Docker ไม่สามารถรันได้
การบังคับใช้มาจากระบบปฏิบัติการแต่ละระบบ Codex ใช้ Seatbelt บน macOS, bubblewrap ร่วมกับ seccomp-bpf บน Linux และกำลังย้าย Windows ไปใช้ไลบรารี MXC (Microsoft eXecution Container) ของ Microsoft โปรเซสลูกจะสืบทอดแซนด์บ็อกซ์ไปด้วย ดังนั้นขีดจำกัดจึงครอบคลุมทั้งโครงสร้างโปรเซส
โปรไฟล์สิทธิ์ของ Codex ควบคุมอะไรบ้าง?
โปรไฟล์สิทธิ์ (permission profile) กำหนดกฎระบบไฟล์และเครือข่ายสำหรับเซสชัน โปรไฟล์ :workspace ที่มีมาให้อนุญาตให้เขียนภายในเวิร์กสเปซ ทำให้ .git และ .codex เป็นแบบอ่านอย่างเดียว อนุญาตให้อ่านได้กว้าง และปิดการเข้าถึงเครือข่าย คุณสามารถขยายเพิ่มได้:
default_permissions = "dev"
[permissions.dev]
description = "Development with extra read-only protections."
extends = ":workspace"
[permissions.dev.filesystem]
"~/build-cache" = "write"
[permissions.dev.filesystem.":workspace_roots"]
".vscode" = "read"
"**/*.env" = "deny"
"secrets" = "deny"
กฎเครือข่ายจะผ่านพร็อกซีที่ตรวจสอบแต่ละคำขอเทียบกับรายการที่อนุญาตและปฏิเสธ กฎการปฏิเสธมีผลเหนือกว่า คำขอไปยังโดเมนที่ไม่อยู่ในรายการจะถูกพักไว้ระหว่างที่ Codex ถามผู้ใช้หรือส่งต่อไปยังการตรวจสอบอัตโนมัติ เอกสารอ้างอิงคีย์ทั้งหมดอยู่ใน เอกสารสิทธิ์ของ Codex
ผู้ดูแลระบบบังคับใช้ขีดจำกัดอย่างไร?
การควบคุมระดับทีมมาจาก ข้อกำหนดที่จัดการได้ใน requirements.toml ซึ่งอาจมาจากไฟล์ระบบหรือนโยบายบนคลาวด์ ตัวอย่างของ OpenAI กำหนดให้ผู้ใช้ทุกคนเป็นแบบอ่านอย่างเดียว:
default_permissions = ":read-only"
[allowed_permission_profiles]
":read-only" = true
":danger-full-access" = false
การยกระดับสิทธิ์เป็นไปอย่างชัดเจน คำสั่งสามารถขอ with_additional_permissions (สิทธิ์เพิ่มเติมภายในแซนด์บ็อกซ์) หรือ require_escalated (รันนอกแซนด์บ็อกซ์) พร้อมเหตุผลประกอบที่ผู้ใช้มองเห็นได้ ฮาร์เนสเป็นตัวตัดสิน ไม่ใช่โมเดล
มีสองรายละเอียดที่สำคัญต่อการกำกับดูแล ประการแรก codex sandbox --permission-profile dev -- <command> ช่วยให้คุณทดสอบโปรไฟล์ก่อนจะไว้ใจได้ ประการที่สอง Codex ไม่ได้ทำแซนด์บ็อกซ์ให้กับคำสั่งที่เริ่ม stdio MCP server เพราะไม่สามารถคาดเดาได้ว่าเซิร์ฟเวอร์นั้นต้องการอะไร คุณต้องห่อมันเอง
Docker Sandboxes และ AI Governance ทำงานอย่างไร
Docker เลือกเส้นทางตรงกันข้าม Docker Sandboxes มอบไมโคร VM แยกต่างหากให้แต่ละ agent พร้อม Docker Engine, ระบบไฟล์ และเครือข่ายของตัวเอง จัดการผ่าน CLI sbx
AI Governance เพิ่มนโยบายระดับองค์กรเข้าไปอีกชั้น ประกอบด้วยสามส่วน:
- นโยบายแซนด์บ็อกซ์: อนุญาตหรือบล็อกโดเมน ช่วง IP และพอร์ต รวมทั้งควบคุมว่าพาธโฮสต์ใดจะถูกเมานต์ได้ แบบอ่านอย่างเดียวหรืออ่านเขียน เอกสารการกำกับดูแลระดับองค์กรระบุว่านโยบายนี้เป็นแบบปฏิเสธโดยค่าเริ่มต้น
- การกำกับดูแลเครื่องมือ MCP: นโยบายสำหรับทราฟฟิก MCP ผ่าน MCP Gateway ของ Docker เขียนด้วย Cedar ครอบคลุมว่าเซิร์ฟเวอร์ใดจะลงทะเบียนได้ และการเรียกใช้เครื่องมือ ทรัพยากร และพรอมต์ใดได้รับอนุญาต นโยบายยังสามารถกำหนดให้ต้องยืนยันสำหรับการเรียกบางรายการได้ด้วย
- การตรวจสอบและความโปร่งใส: บันทึกที่มีโครงสร้างของการตัดสินใจตามนโยบายแต่ละครั้ง พร้อมข้อมูลผู้ดำเนินการ การกระทำ เป้าหมาย การตัดสินใจ และเวลา ซึ่งส่งออกหรือส่งต่อไปยัง SIEM ได้
นักพัฒนาสามารถตรวจสอบขอบเขตได้ก่อนเริ่มงาน:
$ sbx policy check network api.anthropic.com
Allowed: api.anthropic.com
$ sbx policy check network blocked.example.com
Denied: blocked.example.com
Docker เปิดเผยตรงไปตรงมาเกี่ยวกับจุดอ่อนจุดหนึ่ง: นโยบาย MCP ใช้ได้เฉพาะกับทราฟฟิกที่ผ่านเกตเวย์ของตนเท่านั้น การเชื่อมต่อโดยตรงกับรีโมต MCP server จะอยู่ภายใต้นโยบายเครือข่ายของแซนด์บ็อกซ์แทน Docker จำหน่าย AI Governance เป็นแพ็กเกจแยกผ่านทีมขาย
แซนด์บ็อกซ์ Codex เทียบกับ Docker AI Governance
| คำถาม | แซนด์บ็อกซ์ Codex | Docker Sandboxes + AI Governance |
|---|---|---|
| agent รันที่ไหน | สภาพแวดล้อมที่คุณมีอยู่ แซนด์บ็อกซ์ระดับ OS | ไมโคร VM แยกต่างหากต่อ agent |
| กฎระบบไฟล์ | โปรไฟล์สิทธิ์: read, write, deny ต่อพาธ |
นโยบายการเมานต์ อ่านอย่างเดียวหรืออ่านเขียน |
| กฎเครือข่าย | พร็อกซีพร้อมรายการอนุญาต/ปฏิเสธโดเมน คำขอที่ไม่อยู่ในรายการถูกพักเพื่อรออนุมัติ | นโยบายโดเมน ช่วง IP และพอร์ต ปฏิเสธโดยค่าเริ่มต้น |
| เครื่องมือ MCP | stdio server ไม่อยู่ในแซนด์บ็อกซ์ เว้นแต่คุณจะห่อด้วย codex sandbox |
นโยบาย Cedar ที่ MCP Gateway |
| การบังคับใช้ของผู้ดูแลระบบ | requirements.toml ระบบหรือคลาวด์ |
Docker Home หรือ AI Governance API |
| การยกระดับสิทธิ์ | คำขอต่อคำสั่ง ผู้ใช้หรือการตรวจสอบอัตโนมัติเป็นตัวตัดสิน | กฎการยืนยันสำหรับการเรียกใช้เครื่องมือที่ระบุ |
| การตรวจสอบ | ไม่ใช่จุดเน้นของโพสต์ | บันทึกการตัดสินใจตามนโยบายที่มีโครงสร้าง |
ใช้แซนด์บ็อกซ์ Codex เมื่อ agent ของคุณต้องใช้เครื่องมือ native ของโฮสต์และคุณใช้งาน Codex เป็นหลัก ใช้แนวทางของ Docker เมื่อคุณต้องการขอบเขตการแยกตัวหนึ่งเดียวสำหรับ agent หลายตัวและเส้นทางการตรวจสอบจากศูนย์กลาง หลายทีมจะใช้ทั้งสองอย่างร่วมกัน
การควบคุมในระดับรันไทม์สิ้นสุดตรงไหน
ทั้งสองระบบตอบคำถามว่า "โปรเซสนี้ทำอะไรได้ในตอนนี้?" แต่ไม่มีใครตอบคำถามว่า "ทำไม agent นี้จึงกำลังรัน ใครเป็นคนขอ และใครรับรองผลลัพธ์?"
ช่องว่างนี้ปรากฏให้เห็นอย่างรวดเร็ว แซนด์บ็อกซ์สามารถบล็อกการเขียนใน .vscode ได้ แต่ไม่สามารถบอกคุณได้ว่า agent ถูกเริ่มจากแล็ปท็อปของใครคนหนึ่งตอนตีสองโดยไม่มีตั๋วงาน บันทึกการตรวจสอบสามารถแสดงการเรียก MCP ที่ได้รับอนุญาต แต่ไม่สามารถแสดงว่ามีคนรีวิว diff ก่อน merge หรือไม่ บันทึกมีเพียงการกระทำ แต่ไม่มีเจตนาและไม่มีการลงนามรับรอง
เราได้กล่าวถึงด้านของแต่ละ agent ไว้ใน สิทธิ์ของ coding agent และด้านการ merge ใน เกตการอนุมัติสำหรับ coding agent การกำกับดูแลในระดับทีมจะเชื่อมทั้งสองเข้าด้วยกัน
Sharkly มอบเจ้าของ งาน และขั้นตอนการรีวิวให้ทุกการรันของ agent อย่างไร
Sharkly ไม่ได้มาแทนที่แซนด์บ็อกซ์ Codex หรือ Docker Sandboxes แต่ทำงานอยู่เหนือ coding agent และเพิ่มบันทึกการทำงานที่การควบคุมระดับรันไทม์ขาดไป การแมปกับคำถามทั้งห้าข้อมีดังนี้:
ใครเริ่มได้ ทุก Agent มีการมองเห็นแบบ Personal หรือ Space และการมองเห็นเป็นตัวกำหนดว่าใครสามารถมอบหมาย พูดคุยด้วย หรือเรียกใช้จากคอมเมนต์ในงานได้ Private Space จะเก็บงานให้มองเห็นเฉพาะสมาชิก Space เท่านั้น
รันที่ไหน Computer มีเจ้าของและมีการมองเห็นของตัวเอง เฉพาะเจ้าของเท่านั้นที่สามารถลบหรือเปลี่ยนว่าองค์กรใดใช้ Computer ส่วนตัวได้ และ Organization Admin ไม่สามารถ override สิ่งนั้นได้ เจ้าของสามารถยกเลิกการผูก Agent ได้ ซึ่งจะยกเลิกการรันที่ยังทำงานอยู่
ได้รับอะไร การรันที่ผูกกับงานจะนำพางาน คอมเมนต์ล่าสุด คำสั่งของ Agent, Skills, รีโพซิทอรี และเฉพาะตัวแปรสภาพแวดล้อมและการผูก secret ที่กำหนดไว้เท่านั้น แต่ละงานได้รับไดเรกทอรีแยก และงานในรีโพซิทอรีสามารถใช้เวิร์กทรีแยกต่อการรันแต่ละครั้ง
ใครอนุมัติ เวิร์กโฟลว์ของประเภทงานกำหนดจำกัดว่าสถานะใดที่ Agent ตั้งได้ Agent สามารถปล่อยงานให้รอการรีวิวจากมนุษย์ ซึ่งจะไปปรากฏใน Inbox ของผู้รับผิดชอบ
มีบันทึกอะไรไว้ บันทึกการทำงานแสดงแหล่งที่มาของการทริกเกอร์ เวลาเริ่มและสิ้นสุด การเรียกใช้เครื่องมือ เหตุการณ์ในรันไทม์ และรายละเอียดความล้มเหลว ข้อความจาก Agent ที่มีไว้สำหรับทีมจะกลายเป็นคอมเมนต์ที่เชื่อมโยงกับการรันนั้น

ดังนั้นแซนด์บ็อกซ์จึงกำหนดว่าคำสั่งทำอะไรได้ ส่วนงานกำหนดว่าทำไมจึงรันและใครลงนามรับรอง เอกสาร Sharkly อธิบายการมองเห็น, Computer และสถานะการรันไว้อย่างละเอียด
เช็กลิสต์การกำกับดูแลที่คุณนำไปใช้ได้ในสัปดาห์นี้
- ระบุ agent ทุกตัวที่ทีมของคุณใช้งาน และกำหนดเจ้าของที่เป็นมนุษย์หนึ่งคนสำหรับแต่ละตัว
- เขียนโปรไฟล์สิทธิ์หรือนโยบายแซนด์บ็อกซ์หนึ่งชุดต่อบทบาท เริ่มต้นจากแบบอ่านอย่างเดียว
- ทดสอบแต่ละโปรไฟล์ด้วย
codex sandboxหรือsbx policy checkก่อนเปิดใช้งาน - ห่อหรือผ่านเกตเวย์ให้ทุก MCP server อย่าปล่อยให้ stdio server อยู่นอกแซนด์บ็อกซ์
- ปักหมุดโปรไฟล์จากศูนย์กลางด้วย
requirements.tomlหรือนโยบายองค์กร - กำหนดให้ทุกการรันของ agent ต้องมีงาน เพื่อให้แต่ละครั้งมีเหตุผลและผู้รับผิดชอบ
- ส่งผลลัพธ์ไปยังสถานะการรีวิวโดยมนุษย์ก่อน merge
- เก็บ secret ให้ห่างจากข้อความงาน คำสั่ง และ Skills แล้วผูกตามรันไทม์
เช็กลิสต์การป้องกัน secret ของเราลงรายละเอียดขั้นตอนที่ 8 ไว้ลึกกว่า
บทสรุป
agent คือผู้กระทำ ดังนั้นการกำกับดูแลจึงหมายถึงมากกว่าการแยกโปรเซส แซนด์บ็อกซ์ Codex และ Docker AI Governance มอบคำตอบที่แข็งแกร่งสำหรับขีดจำกัดด้านระบบไฟล์ เครือข่าย และเครื่องมือแล้ว แต่ความเป็นเจ้าของ เจตนา และการรีวิวยังต้องการที่อยู่ เลือกแซนด์บ็อกซ์ เขียนโปรไฟล์แรกของคุณ แล้วเชื่อมต่อ agent ของคุณกับ Sharkly เพื่อให้ทุกการรันเริ่มจากงานและจบลงด้วยการลงนามรับรองของคน
คำถามที่พบบ่อย
การกำกับดูแล AI agent กับความปลอดภัยของ AI agent ต่างกันอย่างไร?
ความปลอดภัยคือชั้นการบังคับใช้: แซนด์บ็อกซ์ นโยบายเครือข่าย การจำกัดเครื่องมือ ส่วนการกำกับดูแลนั้นรวมชั้นนี้บวกกับการตัดสินใจรอบ ๆ นั้น: ใครรัน agent ตัวใดได้ ใครอนุมัติการยกระดับสิทธิ์ และใครรับรองผลลัพธ์
แซนด์บ็อกซ์ Codex ทำงานได้โดยไม่ต้องมี Docker ไหม?
ได้ Codex ใช้แซนด์บ็อกซ์ของระบบปฏิบัติการแต่ละระบบ (Seatbelt, bubblewrap ร่วมกับ seccomp หรือ MXC) และรันคำสั่งในสภาพแวดล้อมที่คุณมีอยู่ ไม่ใช่ในคอนเทนเนอร์
ฉันสามารถทำแซนด์บ็อกซ์ให้ MCP server ใน Codex ได้ไหม?
ได้ แต่ไม่ใช่โดยค่าเริ่มต้น Codex ไม่ได้ทำแซนด์บ็อกซ์ให้กับคำสั่งที่เริ่ม stdio MCP server คุณต้องห่อด้วย codex sandbox --permission-profile <name> -- ใน command และ args ของเซิร์ฟเวอร์
Docker AI Governance บันทึกอะไรบ้าง?
บันทึกการตัดสินใจตามนโยบายแซนด์บ็อกซ์และเหตุการณ์ในเซสชัน พร้อมผู้ดำเนินการ การกระทำ เป้าหมาย การตัดสินใจ และเวลา Docker ระบุว่าบันทึกเก็บเฉพาะเมตาดาต้าการกำกับดูแล ไม่ใช่เนื้อหาพรอมต์หรือคำตอบ
ฉันจำเป็นต้องมีทั้งแซนด์บ็อกซ์และบอร์ดงานไหม?
ทั้งสองตอบคำถามต่างกัน แซนด์บ็อกซ์จำกัดว่าคำสั่งทำอะไรได้ ส่วนงานบันทึกว่าการรันเกิดขึ้นทำไม ใครเป็นเจ้าของ และใครรีวิวผลลัพธ์ ทีมที่มี agent มากกว่าหนึ่งตัวมักจำเป็นต้องมีทั้งสองอย่าง
agent สามารถอนุมัติการยกระดับสิทธิ์ของตัวเองได้ไหม?
ไม่ได้ในทั้งสองการออกแบบ ใน Codex ฮาร์เนสเป็นตัวตัดสิน โดยถามผู้ใช้หรือส่งต่อไปยังการตรวจสอบอัตโนมัติ ใน Docker กฎการยืนยันและนโยบายปฏิเสธโดยค่าเริ่มต้นเป็นตัวตัดสิน ไม่ใช่ agent



