Pokee AI Agents สำหรับทีม: จัดการงานระยะยาว มอบหมายและตรวจทานได้ครบวงจร

AI agent ของ Pokee ทำงานรอบละ 90 นาทีใน persistent sandbox พร้อมไฟล์ ทักษะ และหน่วยความจำที่กำหนดขอบเขตไว้อย่างชัดเจน เผยวิธีที่ทีมมอบหมาย ติดตามผล และตรวจทานงานเหล่านี้

Aiden Flux

Aiden Flux

5 พฤศจิกายน 2026

Pokee AI Agents สำหรับทีม: จัดการงานระยะยาว มอบหมายและตรวจทานได้ครบวงจร

TL;DR: เอเจนต์ของ Pokee AI ทำงานผ่าน Pokee Enterprise API โดยแต่ละ tenant จะได้รับแซนด์บ็อกซ์ส่วนตัวแบบคงอยู่ถาวร ซึ่งเอเจนต์สามารถทำงานในหนึ่งรอบ (turn) ได้นานสูงสุดถึง 90 นาที พร้อมกำหนดขอบเขตการเข้าถึงไฟล์ ทักษะที่อัปโหลดไว้ ไฟล์เพอร์โซนาใน .pokee/ และหน่วยความจำที่ยังคงอยู่ข้ามเซสชันได้ ทั้งนี้ API มีหน้าที่รันเอเจนต์ แต่ทีมของคุณยังคงต้องมีพื้นที่สำหรับมอบหมายงาน ติดตามความคืบหน้า และตรวจสอบผลลัพธ์ก่อนที่จะนำไปใช้งานจริง

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

Pokee AI คืออะไร?

Pokee เป็นแพลตฟอร์มเอเจนต์ที่มี Enterprise API ซึ่งนิยามไว้ว่าเป็น “REST API สำหรับรันเวิร์กโฟลว์ของเอเจนต์ที่ทำงานต่อเนื่องยาวนานในแซนด์บ็อกซ์ส่วนตัวแบบคงอยู่ถาวร” โดยแต่ละ tenant จะได้รับพื้นที่ทำงาน (workspace) ส่วนตัว, bearer token รวมถึงเอนด์พอยต์สำหรับ sessions, files, skills และการสตรีมข้อความผ่านที่อยู่อย่าง https://your-tenant.enterprise.pokee.ai การเข้าถึงเป็นระดับองค์กร (Enterprise) โดยในเอกสารของ Pokee จะนำทางลูกค้าใหม่ผ่านปุ่ม “Request demo” และไม่ได้ระบุถึงแพ็กเกจแบบบริการตนเอง (self-serve) หรือแพ็กเกจฟรีไว้แต่อย่างใด

ในหน้ารุ่นโมเดลและราคา มีการระบุระดับโมเดลไว้ 2 ระดับด้วยกัน:

โมเดล อินพุต ($/ล้านโทเคน) เอาต์พุต ($/ล้านโทเคน) อ่านจากแคช ($/ล้านโทเคน)
pokee-isaac-high-reasoning $3 $15 $0.30
pokee-isaac $0.30 $5 $0.10

สำหรับ tenant ใหม่ ระบบจะตั้งค่าเริ่มต้นเป็นระดับ high-reasoning โดยโมเดลจะถูกล็อกไว้ทันทีที่คุณสร้างเซสชัน ดังนั้นทุกรอบในเซสชันดังกล่าวจะทำงานบนโมเดลระดับเดียวกันทั้งหมด

โมเดลเอเจนต์ของ Pokee: เซสชัน, แซนด์บ็อกซ์, ไฟล์, ทักษะ และหน่วยความจำ

โมเดลเอเจนต์ของ Pokee มีส่วนประกอบ 5 ส่วนที่คุณสามารถกำหนดค่าได้ และแต่ละส่วนจะสอดคล้องกับการตัดสินใจภายในทีม

  1. เซสชัน (Sessions) หนึ่งเซสชันคือกระบวนการทำงานของเอเจนต์หนึ่งตัวในแซนด์บ็อกซ์เฉพาะบนพ็อดส่วนตัวของคุณ โดยมีประวัติการทำงาน ขอบเขตไฟล์ และสถานะไม่ว่าง (busy state) แยกเป็นของตัวเอง
  2. โหมดคงอยู่ถาวร (Persistent mode) ตามค่าเริ่มต้น เซสชันจะทำลายตัวเองโดยอัตโนมัติหลังจากตอบกลับข้อความล่าสุดไปแล้ว 5 นาที หากกำหนด persistent: true เซสชันจะคงอยู่จนกว่าจะหมดอายุตาม TTL (ค่าเริ่มต้นคือ 4 ชั่วโมง) หรือจนกว่าคุณจะลบออก
  3. การจำกัดขอบเขตการเข้าถึงไฟล์ (Scoped file access) คุณต้องกำหนดเส้นทางโฟลเดอร์สำหรับ read และ write ในตอนที่สร้างเซสชัน โดยเส้นทางที่อยู่นอกเหนือขอบเขตจะไม่ปรากฏให้เห็นในระบบไฟล์ของเอเจนต์เลย
  4. ทักษะ (Skills) คุณสามารถอัปโหลดไฟล์ zip ที่มีไฟล์ SKILL.md อยู่ที่โฟลเดอร์ราก (root) แล้วทุกเซสชันที่สร้างขึ้นใหม่ใน tenant นั้นจะสามารถเข้าถึงทักษะดังกล่าวได้
  5. ไฟล์เพอร์โซนาและหน่วยความจำ (Persona files and memory) เนื้อหา Markdown ใน .pokee/ จะถูกนำไปแทรกไว้ด้านหน้าของ system prompt และไฟล์ .memory/MEMORY.md จะทำหน้าที่ส่งต่อข้อมูลข้อเท็จจริงข้ามเซสชันได้

Pokee จำกัดขอบเขตการเข้าถึงไฟล์อย่างไร?

การจำกัดขอบเขตจะถูกบังคับใช้ 2 ชั้นด้วยกัน โดยภายในตัวเอเจนต์ mount namespace ของ bubblewrap ระดับเซสชันจะซ่อนทุกสิ่งที่อยู่นอกเหนือเส้นทางที่อนุญาตไว้ ส่งผลให้การพยายามอ่านไฟล์ดังกล่าวส่งกลับค่า ENOENT ขณะที่เมื่อเรียกผ่าน HTTP file API คำขอเดียวกันนี้จะตอบกลับเป็น 403 Forbidden

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

curl -X POST "$POKEE_API/v1/sessions" \
  -H "Authorization: Bearer $POKEE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "persistent": true,
    "ttl": 14400,
    "metadata": {"board_task": "COIN-412", "client": "acme-corp"},
    "file_access": {
      "read": ["projects/acme-corp", "shared/templates"],
      "write": ["projects/acme-corp/output"]
    }
  }'

ขอบเขตการเข้าถึงไฟล์จะไม่สามารถเปลี่ยนแปลงได้ตลอดอายุการทำงานของเซสชัน หากต้องการขยายขอบเขต คุณจะต้องทำลายเซสชันเดิมแล้วสร้างเซสชันใหม่ขึ้นมา ข้อกำหนดนี้ช่วยในเรื่องการปฏิบัติตามกฎระเบียบ (compliance) และช่วยให้ทีมต้องตัดสินใจให้ชัดเจน นั่นคือการกำหนดขอบเขตตั้งแต่ตอนมอบหมายงาน ไม่ใช่มาปรับแก้ระหว่างทาง

ไฟล์เพอร์โซนาใน .pokee/ และหน่วยความจำมีหน้าที่อะไร?

ไฟล์ใน workspace/.pokee/*.md จะถูกโหลดเรียงตามลำดับตัวอักษรเข้าไปใน system prompt โดยแต่ละไฟล์จะอยู่ภายใต้หัวข้อ ## <filename> ในคู่มือตัวอย่างการกำหนดเพอร์โซนา ได้ใช้ 00_soul.md สำหรับกำหนดน้ำเสียงและบุคลิก, 10_glossary.md สำหรับคำศัพท์เฉพาะทาง และ 20_style_guide.md สำหรับรูปแบบการจัดหน้า โดยจำกัดขนาดรวมทั้งไดเรกทอรีไม่เกิน 1 MB

การเปลี่ยนแปลงใด ๆ จะมีผลกับเซสชันถัดไป ส่วนเซสชันที่กำลังทำงานอยู่จะยังคงใช้ prompt เดิม นอกจากนี้ เอเจนต์ยังอ่านและอัปเดตไฟล์ .memory/MEMORY.md ในแต่ละเซสชันด้วย ซึ่งคุณสามารถแก้ไขไฟล์นี้ผ่าน API จัดการไฟล์ หรือจะขอให้ทาง Pokee ปิดการทำงานตามที่ระบุไว้ในหน้าบริบทของเอเจนต์ ก็ได้เช่นกัน

AI Agent ที่ทำงานระยะยาวมีความหมายอย่างไรต่อการทำงานของทีม

AI agent ที่ทำงานระยะยาวจะเข้ามาเปลี่ยนกิจวัตรการทำงานของทีมใน 3 ด้าน ได้แก่ ใครเป็นผู้เริ่มงาน, คุณจะรู้ได้อย่างไรว่างานกำลังคืบหน้า และใครเป็นผู้ตรวจรับงาน ซึ่งขีดจำกัดเริ่มต้นของ Pokee ทำให้ประเด็นเหล่านี้เห็นภาพชัดเจนยิ่งขึ้น

ขีดจำกัด ค่าเริ่มต้น
เซสชันที่ทำงานพร้อมกัน 10
เวลาหมดเขตต่อรอบการทำงาน 90 นาที
อายุเซสชัน (TTL) 4 ชั่วโมง
จำนวนรอบต่อชั่วโมง / ต่อวัน 300 / 5,000
จำนวนโทเคนต่อชั่วโมง / ต่อวัน 20M / 200M
ขนาดพื้นที่ทำงานสูงสุด 100 GB

ทาง Pokee ระบุว่าขีดจำกัดเหล่านี้สามารถขอเพิ่มได้ตามต้องการ

ใครเป็นผู้มอบหมายงานเอเจนต์ที่ต้องทำถึง 90 นาที?

การรันพร้อมกันได้ 10 เซสชันอาจฟังดูเหลือเฟือ จนกระทั่งถึงเช้าวันจันทร์ที่สมาชิก 5 คนต่างสั่งสร้างรายงานคนละ 2 ชิ้นพร้อมกัน ยิ่งไปกว่านั้น เซสชันที่อยู่ในสถานะไม่ว่าง (busy) จะปฏิเสธข้อความที่สองด้วยรหัส 409 ด้วยเหตุนี้ จึงต้องมีใครสักคนคอยเลือกงาน เลือกระดับโมเดล กำหนดขอบเขตไฟล์ และจัดสรรเซสชัน พร้อมทั้งบันทึกลงใน task ที่ระบุผู้รับผิดชอบชัดเจน เพื่อป้องกันไม่ให้มีสองคนสั่งเริ่มงานชิ้นเดียวกันที่ต้องใช้เวลาถึง 90 นาทีซ้ำซ้อนกัน

จะติดตามได้อย่างไรว่าเอเจนต์กำลังทำอะไรอยู่ในระหว่างรอบการทำงานที่ยาวนาน?

เอเจนต์จะยังคงทำงานต่อไปแม้ไคลเอนต์ของคุณจะตัดการเชื่อมต่อแล้วก็ตาม ในคู่มือตัวอย่างงานที่ใช้เวลานาน แนะนำให้ทำการโพล GET /v1/sessions/{id} ทุก ๆ 15 วินาที เพื่อเช็กแฟล็ก busy พร้อมอ่านคีย์ความคืบหน้าที่เวิร์กโฟลว์เขียนลงใน metadata จากนั้นจึงดาวน์โหลดไฟล์ผลลัพธ์ออกมา

while True:
    s = c.get(f"/v1/sessions/{sid}").json()
    if not s["busy"]:
        break
    print(f"metadata: {s['metadata']}")
    time.sleep(15)

สำหรับการสตรีมจะทำงานผ่าน Server-Sent Events โดยมีอีเวนต์ต่าง ๆ เช่น message.created, message.completed, message.error และ message.cancelled ทั้งนี้ เอนด์พอยต์สำหรับเชื่อมต่อใหม่ สามารถกู้คืนสตรีมที่หลุดไปได้จาก Last-Event-ID โดยไม่คิดค่าโทเคนซ้ำซ้อน แต่นั่นเป็นเพียงการบอกสคริปต์ของคุณว่ารอบการทำงานเสร็จสิ้นแล้ว ไม่ได้บอกว่ารายงานที่ได้นั้นมีคุณภาพดีหรือไม่

ใครเป็นผู้ตรวจสอบผลลัพธ์ก่อนส่งมอบงานจริง?

Pokee จะเขียนไฟล์ลงในพื้นที่ทำงาน แต่ขั้นตอนการตรวจสอบเป็นหน้าที่ของมนุษย์ที่อยู่นอกเหนือตัว API นั่นคือต้องมีคนเปิดไฟล์ report.md ขึ้นมาตรวจเทียบกับบรีฟ แล้วอนุมัติหรือส่งกลับไปแก้ไข ซึ่งในการทำงานของเอเจนต์ที่รันพร้อมกันแบบคู่ขนาน ขั้นตอนนี้มักจะกลายเป็นคอขวดหลัก ดังที่มีการวิเคราะห์ไว้ในบทความเรื่อง การตรวจสอบโดยมนุษย์คือคอขวด

Lifecycle of one long-running Pokee agent task: assigned on the board, session created with scoped files, a 90-minute turn running in the sandbox, output file written, then human review before it ships.

ตัวอย่างการทำงานจริง: การจัดทำรายงานลูกค้าตั้งแต่การมอบหมายงานไปจนถึงการตรวจสอบ

สมมติว่ามีทีมงาน 3 คนที่ใช้ Pokee tenant ร่วมกัน โดยชิ้นงานที่ต้องส่งมอบคือรายงานการตลาดประจำไตรมาสสำหรับ “Acme Corp.”

  1. มอบหมายงาน (Assign) Dana สร้าง task: “รายงานการตลาด Q3 สำหรับ Acme” โดยกำหนดให้ Dana เป็นผู้รับผิดชอบ, Sam เป็นผู้ตรวจสอบ และมีกำหนดส่งวันพฤหัสบดี
  2. กำหนดขอบเขต (Scope) task ดังกล่าวจะระบุโมเดล Pokee (pokee-isaac-high-reasoning), เส้นทางสำหรับอ่าน (projects/acme-corp, shared/templates) และเส้นทางสำหรับเขียน (projects/acme-corp/output)
  3. เริ่มงาน (Start) Dana สร้าง persistent session โดยใส่ task ID ไว้ใน metadata จากนั้นส่งข้อความแรกเพื่อสั่งให้สร้างรายงานไว้ที่ output/report.md
  4. ติดตามงาน (Track) นำ session ID ไปใส่ไว้ในคอมเมนต์ของ task ซึ่งใครก็ตามที่โพลคำขอ GET /v1/sessions/{id} จะเห็นสถานะ busy: true จนกว่ารอบการทำงานจะเสร็จสมบูรณ์
  5. รับผลลัพธ์ (Collect) เมื่อสถานะ busy เปลี่ยนกลับเป็น false ทาง Dana จะดาวน์โหลดไฟล์และแนบกลับเข้ามาใน task
  6. ตรวจสอบ (Review) Sam อ่านรายงานเทียบกับบรีฟ หากยังมีจุดที่ไม่ผ่านก็จะส่งกลับไปพร้อมความคิดเห็นและเปิดรอบการทำงานใหม่ แต่หากผ่านก็จะเลื่อนสถานะงานต่อไป
  7. ล้างข้อมูล (Clean up) Dana ทำการลบเซสชัน หรือปล่อยให้สคริปต์รอบดึกที่เรียกคำสั่ง DELETE /v1/sessions?status=idle&older_than=1h กวาดลบโดยอัตโนมัติ

ขั้นตอนที่ 1, 4 และ 6 ไม่ใช่การเรียกใช้งาน API แต่เป็นเรื่องของการประสานงาน ซึ่งมักเป็นขั้นตอนที่หลายทีมมองข้ามเวลาที่เอเจนต์ทำงานได้เร็ว และจะเริ่มเสียดายเมื่อพบว่างานนั้นกินเวลาถึงหนึ่งชั่วโมง

Sharkly เข้ามาตอบโจทย์งานเอเจนต์ของ Pokee ตรงไหน

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

ในทางปฏิบัติ กระบวนการทำงานจะเป็นดังนี้:

  • การมอบหมายงาน (Assignment) งานของ Pokee จะอยู่บนบอร์ดพร้อมระบุผู้รับผิดชอบ (Assignee) และสถานะ ควบคู่ไปกับงานอื่น ๆ ของทุกคนในทีม อ่านเพิ่มเติมได้ในบทความเรื่อง ทีมที่ทำงานร่วมกับเอเจนต์ ว่าเหตุใดการระบุความเป็นเจ้าของงานจึงต้องมีความชัดเจน
  • เอเจนต์ที่สั่งการ API (An Agent that drives the API) Sharkly Agent จะทำงานบนคอมพิวเตอร์ของคุณเองผ่าน Runtime เช่น Claude Code เพียงกำหนดสกิลที่ครอบคำสั่งเรียก curl ข้างต้น เอเจนต์นี้ก็สามารถสร้างเซสชัน โพลติดตามสถานะ และส่ง session ID พร้อมผลลัพธ์กลับมาอัปเดตลงใน task ได้โดยอัตโนมัติ
  • การกำหนดขีดจำกัดการทำงานให้สอดคล้องกับ Pokee (Run limits that match Pokee’s) เอเจนต์แต่ละตัวจะมีการตั้งค่า Run settings ได้แก่ จำนวนงานสูงสุดที่ทำพร้อมกัน, ระยะเวลาทำงานสูงสุดต่องาน และระยะเวลาหมดเวลาของคิว ในตัวอย่างด้านล่าง เอเจนต์ถูกจำกัดไว้ที่ 1 งานและระยะเวลา 40 นาที สำหรับงานของ Pokee ให้ควบคุมจำนวนงานพร้อมกันไม่ให้เกิน 10 เซสชัน และตั้งระยะเวลาการทำงานให้ครอบคลุมรอบ 90 นาที หรือจะให้เอเจนต์สั่งเริ่มรอบการทำงานแล้วค่อยกลับมาตรวจสอบภายหลังก็ได้เช่นกัน
Run settings on a Sharkly Agent: max concurrency for assigned tasks, max run time per task, and queue timeout.
  • การตรวจสอบในฐานะสถานะงาน ไม่ใช่แค่ข้อความแจ้งเตือน (Review as a state, not a message) เอเจนต์สามารถเปลี่ยนสถานะงานเป็นรอการตรวจสอบจากมนุษย์ ซึ่งงานนั้นจะถูกส่งตรงไปยัง Inbox ของผู้ตรวจสอบทันที บทความเรื่อง เอเจนต์เขียนโค้ดที่มีมนุษย์คอยกำกับ และ จุดพักอนุมัติสำหรับเอเจนต์เขียนโค้ด จะอธิบายถึงตำแหน่งที่ควรวางจุดพักตรวจเหล่านี้
  • ทริกเกอร์จากภายนอก (Triggers from outside) ระบบ Automation ของ Sharkly รองรับการสั่งงานผ่าน Webhook trigger ซึ่งเป็น URL ลับที่จะเริ่มสั่งรันงานเมื่อมีบริการภายนอกส่งคำขอแบบ POST เข้ามา ทำให้สคริปต์ของคุณสามารถเรียกใช้ได้ทันทีที่รอบการทำงานของ Pokee เสร็จสิ้น

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

เมื่อใดที่ Pokee เหมาะสม และเมื่อใดที่ไม่เหมาะ

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

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

บทสรุป

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

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

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

Pokee Enterprise API คืออะไร?

Pokee Enterprise API คือ REST API สำหรับรันเวิร์กโฟลว์ของเอเจนต์ที่ทำงานต่อเนื่องยาวนานในแซนด์บ็อกซ์ส่วนตัวแบบคงอยู่ถาวรแยกตามแต่ละ tenant คุณจะได้รับเอนด์พอยต์สำหรับการจัดการเซสชัน, ไฟล์, ทักษะ, การสตรีมข้อความ และการตรวจสอบการใช้งาน โดยยืนยันตัวตนผ่าน bearer token

เอเจนต์ของ Pokee สามารถทำงานได้นานแค่ไหน?

หนึ่งรอบการทำงานสามารถรันได้นานสูงสุด 90 นาทีตามค่าเริ่มต้น และหนึ่งเซสชันอยู่ได้นานสูงสุด 4 ชั่วโมง โดยทั้งสองค่านี้สามารถขอเพิ่มขีดจำกัดได้ตามต้องการ

Pokee AI ใช้งานฟรีหรือไม่?

ในเอกสารไม่ได้ระบุถึงแพ็กเกจฟรี การเข้าถึงจะต้องส่งคำขอเพื่อดูตัวอย่างการใช้งาน (demo) และคิดค่าบริการตามปริมาณโทเคนที่ใช้: โดยมีราคาอินพุต $3 และเอาต์พุต $15 ต่อหนึ่งล้านโทเคนสำหรับรุ่น pokee-isaac-high-reasoning และราคา $0.30 กับ $5 สำหรับรุ่น pokee-isaac

จะเกิดอะไรขึ้นหากมีสองคนส่งข้อความไปยังเซสชัน Pokee เดียวกันพร้อมกัน?

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

เอเจนต์ของ Pokee สามารถจดจำข้อมูลข้ามเซสชันได้หรือไม่?

สามารถทำได้ โดยเอเจนต์จะอ่านและอัปเดตไฟล์ workspace/.memory/MEMORY.md ในแต่ละเซสชัน และไฟล์นี้จะยังคงอยู่แม้พ็อดจะรีสตาร์ตก็ตาม

Sharkly สามารถรันเอเจนต์ของ Pokee โดยตรงได้หรือไม่?

ไม่ได้ เนื่องจาก Sharkly ไม่มีตัวเชื่อมต่อกับ Pokee โดยตรง แต่ Sharkly Agent บนคอมพิวเตอร์ของคุณสามารถเรียกใช้ Pokee API ผ่านทักษะ (skill) ได้ โดยที่ task บน Sharkly จะทำหน้าที่จัดการเรื่องการมอบหมายงาน ติดตามสถานะ และรอการตรวจสอบจากมนุษย์

สำรวจเพิ่มเติม

การกำกับดูแล AI Agent: แซนด์บ็อกซ์ไม่ใช่จุดอนุมัติสุดท้าย

การกำกับดูแล AI Agent: แซนด์บ็อกซ์ไม่ใช่จุดอนุมัติสุดท้าย

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

20 พฤศจิกายน 2026

ทางเลือกโอเพนซอร์สแทน Slack: ExitPath ช่วยให้คุณย้ายออกได้อย่างไร

ทางเลือกโอเพนซอร์สแทน Slack: ExitPath ช่วยให้คุณย้ายออกได้อย่างไร

อยากได้ตัวเลือกแทน Slack แบบโอเพนซอร์สไหม ดูว่า ExitPath แนะนำเรื่องการย้ายไป Mattermost, Zulip หรือ Element ไว้อย่างไร และอย่าปล่อยให้งานของเอเจนต์ของคุณหลุดหาย

20 พฤศจิกายน 2026

เปรียบเทียบ GPT-6.2 Astra กับ Fable 5.2: ทดสอบทั้งคู่บนรีโปของคุณเอง

เปรียบเทียบ GPT-6.2 Astra กับ Fable 5.2: ทดสอบทั้งคู่บนรีโปของคุณเอง

GPT-6.2 Astra กับ Fable 5.2: ตัวไหนควรใช้รัน coding agent ของคุณ? ดูว่าเมื่อโทเคนราคาเท่ากัน ค่าใช้จ่ายของทั้งสองตัวแยกกันตรงไหน แล้วลองใช้ทั้งคู่กับ repo ของคุณเอง

20 พฤศจิกายน 2026