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 ส่วนที่คุณสามารถกำหนดค่าได้ และแต่ละส่วนจะสอดคล้องกับการตัดสินใจภายในทีม
- เซสชัน (Sessions) หนึ่งเซสชันคือกระบวนการทำงานของเอเจนต์หนึ่งตัวในแซนด์บ็อกซ์เฉพาะบนพ็อดส่วนตัวของคุณ โดยมีประวัติการทำงาน ขอบเขตไฟล์ และสถานะไม่ว่าง (busy state) แยกเป็นของตัวเอง
- โหมดคงอยู่ถาวร (Persistent mode) ตามค่าเริ่มต้น เซสชันจะทำลายตัวเองโดยอัตโนมัติหลังจากตอบกลับข้อความล่าสุดไปแล้ว 5 นาที หากกำหนด
persistent: trueเซสชันจะคงอยู่จนกว่าจะหมดอายุตาม TTL (ค่าเริ่มต้นคือ 4 ชั่วโมง) หรือจนกว่าคุณจะลบออก - การจำกัดขอบเขตการเข้าถึงไฟล์ (Scoped file access) คุณต้องกำหนดเส้นทางโฟลเดอร์สำหรับ
readและwriteในตอนที่สร้างเซสชัน โดยเส้นทางที่อยู่นอกเหนือขอบเขตจะไม่ปรากฏให้เห็นในระบบไฟล์ของเอเจนต์เลย - ทักษะ (Skills) คุณสามารถอัปโหลดไฟล์ zip ที่มีไฟล์
SKILL.mdอยู่ที่โฟลเดอร์ราก (root) แล้วทุกเซสชันที่สร้างขึ้นใหม่ใน tenant นั้นจะสามารถเข้าถึงทักษะดังกล่าวได้ - ไฟล์เพอร์โซนาและหน่วยความจำ (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 ขึ้นมาตรวจเทียบกับบรีฟ แล้วอนุมัติหรือส่งกลับไปแก้ไข ซึ่งในการทำงานของเอเจนต์ที่รันพร้อมกันแบบคู่ขนาน ขั้นตอนนี้มักจะกลายเป็นคอขวดหลัก ดังที่มีการวิเคราะห์ไว้ในบทความเรื่อง การตรวจสอบโดยมนุษย์คือคอขวด

ตัวอย่างการทำงานจริง: การจัดทำรายงานลูกค้าตั้งแต่การมอบหมายงานไปจนถึงการตรวจสอบ
สมมติว่ามีทีมงาน 3 คนที่ใช้ Pokee tenant ร่วมกัน โดยชิ้นงานที่ต้องส่งมอบคือรายงานการตลาดประจำไตรมาสสำหรับ “Acme Corp.”
- มอบหมายงาน (Assign) Dana สร้าง task: “รายงานการตลาด Q3 สำหรับ Acme” โดยกำหนดให้ Dana เป็นผู้รับผิดชอบ, Sam เป็นผู้ตรวจสอบ และมีกำหนดส่งวันพฤหัสบดี
- กำหนดขอบเขต (Scope) task ดังกล่าวจะระบุโมเดล Pokee (
pokee-isaac-high-reasoning), เส้นทางสำหรับอ่าน (projects/acme-corp,shared/templates) และเส้นทางสำหรับเขียน (projects/acme-corp/output) - เริ่มงาน (Start) Dana สร้าง persistent session โดยใส่ task ID ไว้ใน
metadataจากนั้นส่งข้อความแรกเพื่อสั่งให้สร้างรายงานไว้ที่output/report.md - ติดตามงาน (Track) นำ session ID ไปใส่ไว้ในคอมเมนต์ของ task ซึ่งใครก็ตามที่โพลคำขอ
GET /v1/sessions/{id}จะเห็นสถานะbusy: trueจนกว่ารอบการทำงานจะเสร็จสมบูรณ์ - รับผลลัพธ์ (Collect) เมื่อสถานะ
busyเปลี่ยนกลับเป็น false ทาง Dana จะดาวน์โหลดไฟล์และแนบกลับเข้ามาใน task - ตรวจสอบ (Review) Sam อ่านรายงานเทียบกับบรีฟ หากยังมีจุดที่ไม่ผ่านก็จะส่งกลับไปพร้อมความคิดเห็นและเปิดรอบการทำงานใหม่ แต่หากผ่านก็จะเลื่อนสถานะงานต่อไป
- ล้างข้อมูล (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 นาที หรือจะให้เอเจนต์สั่งเริ่มรอบการทำงานแล้วค่อยกลับมาตรวจสอบภายหลังก็ได้เช่นกัน

- การตรวจสอบในฐานะสถานะงาน ไม่ใช่แค่ข้อความแจ้งเตือน (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 จะทำหน้าที่จัดการเรื่องการมอบหมายงาน ติดตามสถานะ และรอการตรวจสอบจากมนุษย์



